edsger 0.53.0 → 0.54.1

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -4,6 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { gitPush } from '../../utils/git-push.js';
+import { resolveDefaultBranch } from '../../utils/github-repo-info.js';
 import { logError, logInfo } from '../../utils/logger.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
@@ -44,7 +45,8 @@ export function devBranchToFeatBranch(devBranchName) {
  * Create a pull request from a dev/ branch to its corresponding feat/ branch
  * This is used after code implementation in multi-branch issues
  */
-export async function createBranchPullRequest(config, devBranchName, issueName, branchDescription, baseBranch = 'main') {
+export async function createBranchPullRequest(config, devBranchName, issueName, branchDescription, baseBranch) {
+    const resolvedBaseBranch = baseBranch ?? resolveDefaultBranch();
     const { githubToken, owner, repo, verbose } = config;
     if (!devBranchName.startsWith('dev/')) {
         return {
@@ -75,13 +77,13 @@ export async function createBranchPullRequest(config, devBranchName, issueName,
             logInfo(`📝 Ensuring target branch ${featBranchName} exists...`);
         }
         try {
-            // Get the base branch (main) SHA
+            // Get the base branch SHA
             const { data: baseBranchData } = await octokit.repos.getBranch({
                 owner,
                 repo,
-                branch: baseBranch,
+                branch: resolvedBaseBranch,
             });
-            // Create the feat/ branch from main
+            // Create the feat/ branch from the resolved base
             await octokit.git.createRef({
                 owner,
                 repo,
@@ -89,7 +91,7 @@ export async function createBranchPullRequest(config, devBranchName, issueName,
                 sha: baseBranchData.commit.sha,
             });
             if (verbose) {
-                logInfo(`✅ Created target branch ${featBranchName} from ${baseBranch}`);
+                logInfo(`✅ Created target branch ${featBranchName} from ${resolvedBaseBranch}`);
             }
         }
         catch (error) {

package/dist/phases/code-implementation/index.js

@@ -8,6 +8,7 @@ import { createBranches, getBaseBranchInfo, getBranches, getCurrentBranch, updat
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { prepareCustomBranchGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { gitPush } from '../../utils/git-push.js';
 import { extractJsonFromResponse } from '../../utils/json-extractor.js';
@@ -170,9 +171,11 @@ message, lastAssistantResponse, issueId, verbose
     }
     return null;
 }
-// eslint-disable-next-line complexity
 export const implementIssueCode = async (options, config, checklistContext) => {
-    const { issueId, verbose, baseBranch = 'main' } = options;
+    const { issueId, verbose } = options;
+    // Resolve the repo's default branch (handles forks where default is master, etc.).
+    // Caller may override via options.baseBranch (e.g. branch-chained PR base).
+    const baseBranch = options.baseBranch ?? (await getDefaultBranchForIssue(issueId, verbose));
     if (verbose) {
         logInfo(`Starting code implementation for issue ID: ${issueId}`);
         logInfo(`Base branch: ${baseBranch}`);
@@ -322,7 +325,7 @@ export const implementIssueCode = async (options, config, checklistContext) => {
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch,
                     verbose,
                 });
             }

package/dist/phases/code-implementation-verification/agent.js

@@ -125,7 +125,12 @@ function parseVerificationResult(responseText, verbose) {
 /**
  * Process assistant messages to accumulate response text
  */
-function processAssistantContent(content, responseAccumulator, verbose) {
+function processAssistantContent(
+// SDK 0.2.124+ tightened the BetaContentBlock union; accept the wider
+// shape and narrow at use sites. This helper only reads fields that
+// exist on the `text` and `tool_use` variants.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+content, responseAccumulator, verbose) {
     if (content.type === 'text' && content.text) {
         responseAccumulator.text += `${content.text}\n`;
         logDebug(`🔍 ${content.text}`, verbose);

package/dist/phases/code-refine/index.js

@@ -6,6 +6,7 @@
 import { getGitHubConfig } from '../../api/github.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { getUncommittedFiles, hasUncommittedChanges, prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { gitPushCurrentBranch } from '../../utils/git-push.js';
 import { logError, logInfo } from '../../utils/logger.js';
@@ -41,18 +42,19 @@ export const MAX_REFINE_ITERATIONS = 10;
  * Similar to technical-design, this includes an iterative improvement cycle:
  * refine → verification → improve → re-refine (if needed)
  */
-// eslint-disable-next-line complexity
 export const refineCodeFromPRFeedback = async (options, config, checklistContext) => {
     const { issueId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code refine for issue ID: ${issueId}`);
     }
+    // Resolve the repo's default branch (handles forks where default is master, etc.)
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
     // For multi-branch issues, find the branch that has been reviewed
     // (status = 'reviewed' after code-review phase) and use its branch_name for refine
     let branchName = `dev/${issueId}`; // Default for single-branch issues
     let currentBranch = null;
     let allBranches = [];
-    let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
     let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     let baseBranchCompletedForRebase = false;
@@ -68,7 +70,7 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
                 logInfo(`   Using dev branch: ${branchName}`);
             }
             // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, 'main');
+            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
             // - Base branch merged: returns feat branch (new branches created from feat/xxx)
@@ -114,14 +116,14 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
                 githubConfig.repo) {
                 const featBranchName = branchName.replace(/^dev\//, 'feat/');
                 if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with main before rebase...`);
+                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
                 }
                 featSyncedToMain = await syncFeatBranchWithMain({
                     featBranch: featBranchName,
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch: defaultBranch,
                     verbose,
                 });
             }
@@ -150,7 +152,7 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
             baseBranchCompleted: baseBranchCompletedForRebase,
             githubToken,
         })
-        : await preparePhaseGitEnvironmentAsync(issueId, 'main', verbose, true, {
+        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
             model: DEFAULT_MODEL,
         });
     const cleanupGit = gitEnvResult.cleanup;

package/dist/phases/code-refine/refine-iteration.js

@@ -77,7 +77,8 @@ export async function executeRefineIteration(opts) {
                     logDebug(`🔧 ${content.text}`, verbose);
                 }
                 else if (content.type === 'tool_use') {
-                    logDebug(`🛠️ ${content.name}: ${content.input.description || 'Running...'}`, verbose);
+                    const input = (content.input ?? {});
+                    logDebug(`🛠️ ${content.name}: ${input.description ?? 'Running...'}`, verbose);
                 }
             }
             continue;

package/dist/phases/code-review/index.js

@@ -10,6 +10,7 @@ import { DEFAULT_MODEL } from '../../constants.js';
 import { getBaseBranchInfo, getBranches, updateBranch, } from '../../services/branches.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
 import { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, syncFeatBranchWithMain, } from '../../utils/git-branch-manager.js';
 import { logError, logInfo } from '../../utils/logger.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
@@ -67,18 +68,19 @@ baseBranchInfo, baseBranchForRebase, originalBaseBranchForRebase, verbose) {
 /**
  * Main code review function
  */
-// eslint-disable-next-line complexity
 export const reviewPullRequest = async (options, config, checklistContext) => {
     const { issueId, githubToken, verbose } = options;
     if (verbose) {
         logInfo(`Starting code review for issue ID: ${issueId}`);
     }
+    // Resolve the repo's default branch (handles forks where default is master, etc.)
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
     // For multi-branch issues, find the branch that is ready for review
     // and use its branch_name for review (branch_name is stored as dev/...)
     let branchName = `dev/${issueId}`; // Default for single-branch issues
     let currentBranch = null;
     let allBranches = [];
-    let baseBranchForRebase = 'main'; // Default base branch for rebase
+    let baseBranchForRebase = defaultBranch; // Default base branch for rebase
     let rebaseTargetBranchForRebase; // Target for --onto rebase (e.g., main)
     let originalBaseBranchForRebase; // For --onto when base was squash-merged
     let baseBranchCompletedForRebase = false;
@@ -95,7 +97,7 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
                 logInfo(`   Using dev branch: ${branchName}`);
             }
             // Determine the correct base branch for rebase using base_branch_id
-            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, 'main');
+            const baseBranchInfo = getBaseBranchInfo(currentBranch, allBranches, defaultBranch);
             // Always use the baseBranch from getBaseBranchInfo - it handles all cases:
             // - No base branch: returns 'main'
             // - Base branch merged: returns feat branch (new branches created from feat/xxx)
@@ -141,14 +143,14 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
                 githubConfig.repo) {
                 const featBranchName = branchName.replace(/^dev\//, 'feat/');
                 if (verbose) {
-                    logInfo(`📥 Syncing ${featBranchName} with main before rebase...`);
+                    logInfo(`📥 Syncing ${featBranchName} with ${defaultBranch} before rebase...`);
                 }
                 featSyncedToMain = await syncFeatBranchWithMain({
                     featBranch: featBranchName,
                     githubToken: githubConfig.token,
                     owner: githubConfig.owner,
                     repo: githubConfig.repo,
-                    baseBranch: 'main',
+                    baseBranch: defaultBranch,
                     verbose,
                 });
             }
@@ -177,7 +179,7 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
             baseBranchCompleted: baseBranchCompletedForRebase,
             githubToken,
         })
-        : await preparePhaseGitEnvironmentAsync(issueId, 'main', verbose, true, {
+        : await preparePhaseGitEnvironmentAsync(issueId, defaultBranch, verbose, true, {
             model: DEFAULT_MODEL,
         });
     const cleanupGit = gitEnvResult.cleanup;

package/dist/phases/code-testing/analyzer.js

@@ -1,5 +1,11 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
+import { getDefaultBranchForIssue } from '../../services/repo-config.js';
+import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
+import { extractJsonFromResponse } from '../../utils/json-extractor.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
+import { createCodeTestingPromptWithContext, createCodeTestingSystemPrompt, } from './prompts.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function processAssistantContent(content, verbose) {
     let text = '';
@@ -14,11 +20,6 @@ function processAssistantContent(content, verbose) {
     }
     return text;
 }
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
-import { extractJsonFromResponse } from '../../utils/json-extractor.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-import { fetchCodeTestingContext, formatContextForPrompt, } from './context-fetcher.js';
-import { createCodeTestingPromptWithContext, createCodeTestingSystemPrompt, } from './prompts.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -31,14 +32,16 @@ async function* prompt(testingPrompt) {
         setTimeout(res, 10000);
     });
 }
-// eslint-disable-next-line complexity
 export const writeCodeTests = async (options, config) => {
     const { issueId, verbose } = options;
     if (verbose) {
         logInfo(`Starting code testing phase for issue ID: ${issueId}`);
     }
-    // Prepare git environment: switch to issue branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(issueId, 'main', verbose);
+    // Prepare git environment: switch to issue branch and rebase with the
+    // repo's default branch (resolved via GitHub API for consistency with
+    // other phases — same source of truth for forks where origin/HEAD may lag).
+    const defaultBranch = await getDefaultBranchForIssue(issueId, verbose);
+    const cleanupGit = preparePhaseGitEnvironment(issueId, defaultBranch, verbose);
     try {
         // Fetch all required context information via MCP endpoints
         if (verbose) {

package/dist/phases/financing-deck/agent.d.ts

@@ -0,0 +1 @@
+export declare function executeFinancingDeckQuery(userPrompt: string, systemPrompt: string, verbose?: boolean): Promise<Record<string, unknown> | null>;

package/dist/phases/financing-deck/agent.js

@@ -0,0 +1,96 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+/**
+ * Pulls the JSON contract block out of Claude's final assistant message.
+ * Accepts either a fenced ```json block or a bare JSON object — the
+ * fenced form is what the contract asks for.
+ */
+function parseDeckResult(responseText) {
+    try {
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        const jsonText = jsonBlockMatch
+            ? jsonBlockMatch[1]
+            : (responseText.match(/\{[\s\S]*\}/) ?? [responseText])[0];
+        const parsed = JSON.parse(jsonText);
+        if (parsed && Array.isArray(parsed.deck_slides)) {
+            return { deck: parsed };
+        }
+        return { error: 'Missing or empty deck_slides array' };
+    }
+    catch (error) {
+        return {
+            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content },
+    };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* prompt(deckPrompt) {
+    yield userMessage(deckPrompt);
+}
+export async function executeFinancingDeckQuery(userPrompt, systemPrompt, verbose) {
+    let lastAssistantResponse = '';
+    let structured = null;
+    let turnCount = 0;
+    logInfo('Connecting to AI agent...');
+    for await (const message of query({
+        prompt: prompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 40,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistantResponse += `${content.text}\n`;
+                    logDebug(`${content.text}`, verbose);
+                }
+                else if (content.type === 'tool_use') {
+                    const input = (content.input ?? {});
+                    const desc = input.description ?? input.command ?? 'Running...';
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            if (message.subtype === 'success') {
+                logInfo(`\nFinancing deck draft completed after ${turnCount} turns, parsing JSON contract...`);
+                const responseText = message.result || lastAssistantResponse;
+                const parsed = parseDeckResult(responseText);
+                if (parsed.error) {
+                    logError(`Failed to parse deck JSON: ${parsed.error}`);
+                }
+                else {
+                    structured = parsed.deck;
+                }
+            }
+            else {
+                logError(`\nDeck generation incomplete: ${message.subtype}`);
+                if (lastAssistantResponse) {
+                    const parsed = parseDeckResult(lastAssistantResponse);
+                    if (!parsed.error) {
+                        structured = parsed.deck;
+                    }
+                }
+            }
+        }
+    }
+    return structured;
+}

package/dist/phases/financing-deck/context.d.ts

@@ -0,0 +1,13 @@
+import { type FinancingContext, type FinancingStage } from '../../api/financing.js';
+import { type ProductInfo } from '../../api/products.js';
+export interface FinancingDeckContext {
+    product: ProductInfo;
+    financing: FinancingContext;
+    contextSummary: string;
+}
+/**
+ * Pre-fetch product + financing context so we can include a compact
+ * summary in the user prompt. The agent can still call MCP tools for
+ * the full data, but having a baseline summary speeds the first turn.
+ */
+export declare function prepareFinancingDeckContext(productId: string, targetStage: FinancingStage, verbose?: boolean): Promise<FinancingDeckContext>;

package/dist/phases/financing-deck/context.js

@@ -0,0 +1,69 @@
+import { getFinancingContext, } from '../../api/financing.js';
+import { getProduct } from '../../api/products.js';
+import { logError, logInfo } from '../../utils/logger.js';
+/**
+ * Pre-fetch product + financing context so we can include a compact
+ * summary in the user prompt. The agent can still call MCP tools for
+ * the full data, but having a baseline summary speeds the first turn.
+ */
+export async function prepareFinancingDeckContext(productId, targetStage, verbose) {
+    if (verbose) {
+        logInfo(`Fetching financing deck context for product=${productId} stage=${targetStage}`);
+    }
+    let product;
+    let financing;
+    try {
+        ;
+        [product, financing] = await Promise.all([
+            getProduct(productId, verbose),
+            getFinancingContext(productId, targetStage, verbose),
+        ]);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch financing context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+    const issuesCount = product.issues?.length ?? 0;
+    const profile = financing.profile ?? {};
+    const metrics = financing.metrics ?? {};
+    const contextSummary = [
+        `## Product`,
+        `Name: ${product.name}`,
+        `Description: ${product.description ?? '(none)'}`,
+        `Issues tracked: ${issuesCount}`,
+        ``,
+        `## Founder context (self-reported)`,
+        `Current stage: ${profile.current_stage ?? 'not provided'}`,
+        `Target stage: ${targetStage}`,
+        `Target round size USD: ${profile.target_amount_usd ?? 'not provided'}`,
+        `Target valuation USD: ${profile.target_valuation_usd ?? 'not provided'}`,
+        `Use of funds: ${profile.use_of_funds ?? 'not provided'}`,
+        ``,
+        `## Self-reported metrics`,
+        formatMetric(metrics, 'arr_usd', 'ARR (USD)'),
+        formatMetric(metrics, 'mrr_usd', 'MRR (USD)'),
+        formatMetric(metrics, 'paying_customer_count', 'Paying customers'),
+        formatMetric(metrics, 'mom_growth_rate', 'MoM growth (fraction)'),
+        formatMetric(metrics, 'yoy_growth_rate', 'YoY growth (fraction)'),
+        formatMetric(metrics, 'net_revenue_retention', 'NRR (fraction)'),
+        formatMetric(metrics, 'gross_revenue_retention', 'GRR (fraction)'),
+        formatMetric(metrics, 'cac_usd', 'CAC (USD)'),
+        formatMetric(metrics, 'ltv_usd', 'LTV (USD)'),
+        formatMetric(metrics, 'cac_payback_months', 'CAC payback (months)'),
+        formatMetric(metrics, 'gross_margin', 'Gross margin (fraction)'),
+        formatMetric(metrics, 'monthly_burn_usd', 'Monthly burn (USD)'),
+        formatMetric(metrics, 'cash_in_bank_usd', 'Cash in bank (USD)'),
+        formatMetric(metrics, 'runway_months', 'Runway (months)'),
+        formatMetric(metrics, 'burn_multiple', 'Burn Multiple'),
+        formatMetric(metrics, 'fte_count', 'Team FTEs'),
+        ``,
+        `## Industry benchmarks`,
+        `Not bundled — use WebSearch to fetch current ${targetStage} benchmarks for this product's vertical before judging any metric. Cite source URLs in stage_reasoning and red flags.`,
+    ].join('\n');
+    return { product, financing, contextSummary };
+}
+function formatMetric(metrics, key, label) {
+    const v = metrics[key];
+    return `- ${label}: ${v === null || v === undefined ? 'not provided' : String(v)}`;
+}

package/dist/phases/financing-deck/index.d.ts

@@ -0,0 +1,15 @@
+import { type FinancingStage } from '../../api/financing.js';
+export interface FinancingDeckOptions {
+    productId: string;
+    targetStage: FinancingStage;
+    verbose?: boolean;
+}
+export interface FinancingDeckResult {
+    productId: string;
+    status: 'success' | 'error';
+    summary: string;
+    analysisId?: string;
+    slideCount: number;
+    redFlagCount: number;
+}
+export declare function generateFinancingDeck(options: FinancingDeckOptions): Promise<FinancingDeckResult>;

package/dist/phases/financing-deck/index.js

@@ -0,0 +1,89 @@
+import { saveFinancingAnalysis, } from '../../api/financing.js';
+import { logError, logInfo, logSuccess, logWarning } from '../../utils/logger.js';
+import { executeFinancingDeckQuery } from './agent.js';
+import { prepareFinancingDeckContext } from './context.js';
+import { createFinancingDeckSystemPrompt, createFinancingDeckUserPrompt, } from './prompts.js';
+const REQUIRED_SLIDE_IDS = [
+    'problem',
+    'solution',
+    'market',
+    'product',
+    'traction',
+    'business_model',
+    'go_to_market',
+    'competition',
+    'team',
+    'financials',
+    'ask',
+];
+export async function generateFinancingDeck(options) {
+    const { productId, targetStage, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting financing deck generation: product=${productId} stage=${targetStage}`);
+    }
+    try {
+        const { contextSummary } = await prepareFinancingDeckContext(productId, targetStage, verbose);
+        const systemPrompt = createFinancingDeckSystemPrompt(targetStage);
+        const userPrompt = createFinancingDeckUserPrompt(productId, targetStage, contextSummary);
+        if (verbose) {
+            logInfo('Starting AI query for financing deck...');
+        }
+        const structured = await executeFinancingDeckQuery(userPrompt, systemPrompt, verbose);
+        if (!structured) {
+            throw new Error('No deck JSON received from agent');
+        }
+        const deckSlides = (structured.deck_slides ?? []);
+        const redFlags = (structured.red_flags ?? []);
+        const stageReasoning = structured.stage_reasoning ?? '';
+        const sourceSummary = structured.source_summary ?? {};
+        // Sanity-check the deck shape — the agent might short-circuit. If so we
+        // still return whatever we got, but warn loudly.
+        const missing = REQUIRED_SLIDE_IDS.filter((id) => !deckSlides.some((s) => s.slide_id === id));
+        if (missing.length > 0) {
+            logWarning(`Deck is missing required slides: ${missing.join(', ')} — saving anyway`);
+        }
+        // The agent should have already called save_financing_analysis via MCP.
+        // We re-save here to GUARANTEE persistence, even if the agent forgot the
+        // tool call but did emit a valid JSON contract. Idempotent at the
+        // analyses-history level (each save creates a new row).
+        let analysisId;
+        if (deckSlides.length > 0) {
+            try {
+                const saved = await saveFinancingAnalysis({
+                    product_id: productId,
+                    target_stage: targetStage,
+                    deck_slides: deckSlides,
+                    stage_reasoning: stageReasoning,
+                    red_flags: redFlags,
+                    source_summary: sourceSummary,
+                }, verbose);
+                analysisId = saved.analysis_id;
+            }
+            catch (saveError) {
+                // Agent likely already saved it — log and continue
+                if (verbose) {
+                    logWarning(`Re-save skipped (agent likely already persisted): ${saveError instanceof Error ? saveError.message : String(saveError)}`);
+                }
+            }
+        }
+        logSuccess(`Financing deck completed: ${deckSlides.length} slides, ${redFlags.length} red flags`);
+        return {
+            productId,
+            status: 'success',
+            summary: stageReasoning || 'Deck draft persisted',
+            analysisId,
+            slideCount: deckSlides.length,
+            redFlagCount: redFlags.length,
+        };
+    }
+    catch (error) {
+        logError(`Financing deck generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        return {
+            productId,
+            status: 'error',
+            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
+            slideCount: 0,
+            redFlagCount: 0,
+        };
+    }
+}

package/dist/phases/financing-deck/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function createFinancingDeckSystemPrompt(targetStage: string): string;
+export declare function createFinancingDeckUserPrompt(productId: string, targetStage: string, contextSummary: string): string;