edsger 0.53.0 → 0.54.1

package/dist/phases/find-architecture/types.js

@@ -0,0 +1,69 @@
+/**
+ * Types for the find-architecture phase.
+ *
+ * Where find-smells covers local "the code would be better if changed" findings
+ * (refactor candidates, dead code, perf cliffs, etc.), this phase zooms out to
+ * **architectural** problems and improvements — module boundaries, layering,
+ * coupling, dependency direction, responsibility creep, missing or duplicated
+ * abstractions, cross-cutting concerns. Findings span multiple files by nature.
+ */
+/**
+ * Authoritative list of allowed concern types. Kept as a `const` array so the
+ * type and the runtime whitelist can never drift apart.
+ */
+export const ARCHITECTURE_CONCERNS = [
+    'layering',
+    'coupling',
+    'cohesion',
+    'cyclic_dependency',
+    'boundary',
+    'duplication',
+    'missing_abstraction',
+    'responsibility_creep',
+    'cross_cutting',
+    'inconsistency',
+    'scalability',
+    'other',
+];
+export function isArchitectureConcern(value) {
+    return (typeof value === 'string' &&
+        ARCHITECTURE_CONCERNS.includes(value));
+}
+export function isDeferredFinding(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    return typeof v.title === 'string' && typeof v.reason === 'string';
+}
+export function isScanResult(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const v = value;
+    if (typeof v.summary !== 'string' || !Array.isArray(v.findings)) {
+        return false;
+    }
+    const findingsOk = v.findings.every((f) => f &&
+        typeof f === 'object' &&
+        typeof f.title === 'string' &&
+        typeof f.description === 'string' &&
+        typeof f.file === 'string');
+    if (!findingsOk) {
+        return false;
+    }
+    for (const key of [
+        'deferred_to_bugs',
+        'deferred_to_features',
+        'deferred_to_smells',
+    ]) {
+        const arr = v[key];
+        if (arr === undefined) {
+            continue;
+        }
+        if (!Array.isArray(arr) || !arr.every(isDeferredFinding)) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/phases/find-bugs/index.js

@@ -6,7 +6,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { detectDefaultBranch, gitRevParse, isAncestor, listChangedPaths, } from '../find-shared/git.js';
 import { createIssue, fetchOpenIssues, fetchProductBasics, } from '../find-shared/mcp.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
@@ -42,15 +42,18 @@ export async function scanForBugs(options) {
             message: 'Another bug scan is already in progress for this product',
         };
     }
+    let repoPath;
+    let scanSucceeded = false;
     try {
         updateFindBugsState(productId, {
             lastAttemptedAt: new Date().toISOString(),
         });
         const workspaceRoot = ensureWorkspaceDir();
-        // Reuse a single workspace per product so incremental scans don't re-clone.
+        // Each run re-clones into a per-product directory and removes it on
+        // success. Incremental scope is recovered from the persisted state file
+        // (~/.edsger/find-bugs-state/<productId>.json), not from the workspace.
         const repoKey = `${WORKSPACE_KEY}-${productId}`;
-        const cloned = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken);
-        const { repoPath } = cloned;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken));
         const branch = options.branch ?? detectDefaultBranch(repoPath);
         logInfo(`Syncing ${owner}/${repo} to branch ${branch}`);
         syncRepoToRef(repoPath, { branch }, githubToken);
@@ -72,6 +75,7 @@ export async function scanForBugs(options) {
                         lastScannedAt: new Date().toISOString(),
                         lastError: undefined,
                     });
+                    scanSucceeded = true;
                     return {
                         status: 'success',
                         message: 'No changes since last scan',
@@ -87,6 +91,7 @@ export async function scanForBugs(options) {
         }
         else if (baseSha === headSha) {
             logSuccess('HEAD unchanged since last scan; nothing to do.');
+            scanSucceeded = true;
             return {
                 status: 'success',
                 message: 'HEAD unchanged since last scan',
@@ -171,6 +176,7 @@ export async function scanForBugs(options) {
             lastScannedAt: new Date().toISOString(),
             lastError: undefined,
         });
+        scanSucceeded = true;
         return {
             status: 'success',
             message: `Filed ${created} of ${bugs.length} candidate bugs`,
@@ -190,6 +196,9 @@ export async function scanForBugs(options) {
         };
     }
     finally {
+        if (scanSucceeded) {
+            cleanupIssueRepo(repoPath);
+        }
         lock.release();
     }
 }

package/dist/phases/find-features/index.js

@@ -16,7 +16,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk';
 import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { detectDefaultBranch } from '../find-shared/git.js';
 import { createIssue, fetchOpenIssues, fetchProductBasics, } from '../find-shared/mcp.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
@@ -48,17 +48,18 @@ export async function scanForFeatures(options) {
             message: 'Another feature discovery run is already in progress for this product',
         };
     }
+    let repoPath;
+    let scanSucceeded = false;
     try {
         updateFindFeaturesState(productId, {
             lastAttemptedAt: new Date().toISOString(),
         });
         // Clone / refresh the repo so the model can verify existing functionality
-        // before proposing new features. Same workspace pattern as find-bugs —
-        // one reusable clone per product, keyed by WORKSPACE_KEY.
+        // before proposing new features. Cleaned up after a successful run; the
+        // worker re-clones on the next invocation.
         const workspaceRoot = ensureWorkspaceDir();
         const repoKey = `${WORKSPACE_KEY}-${productId}`;
-        const cloned = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken);
-        const { repoPath } = cloned;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken));
         const branch = options.branch ?? detectDefaultBranch(repoPath);
         logInfo(`Syncing ${owner}/${repo} to branch ${branch}`);
         syncRepoToRef(repoPath, { branch }, githubToken);
@@ -149,6 +150,7 @@ export async function scanForFeatures(options) {
             lastRunAt: new Date().toISOString(),
             lastError: undefined,
         });
+        scanSucceeded = true;
         return {
             status: 'success',
             message: `Filed ${created} of ${opportunities.length} opportunities`,
@@ -167,6 +169,9 @@ export async function scanForFeatures(options) {
         };
     }
     finally {
+        if (scanSucceeded) {
+            cleanupIssueRepo(repoPath);
+        }
         lock.release();
     }
 }

package/dist/phases/find-smells/index.js

@@ -10,7 +10,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, syncRepoToRef, } from '../../workspace/workspace-manager.js';
 import { detectDefaultBranch, gitRevParse, isAncestor, listChangedPaths, } from '../find-shared/git.js';
 import { createIssue, fetchOpenIssues, fetchProductBasics, } from '../find-shared/mcp.js';
 import { createPromptGenerator, extractTextFromContent, tryExtractResult, } from '../pr-shared/agent-utils.js';
@@ -41,14 +41,15 @@ export async function scanForSmells(options) {
             message: 'Another smell scan is already in progress for this product',
         };
     }
+    let repoPath;
+    let scanSucceeded = false;
     try {
         updateFindSmellsState(productId, {
             lastAttemptedAt: new Date().toISOString(),
         });
         const workspaceRoot = ensureWorkspaceDir();
         const repoKey = `${WORKSPACE_KEY}-${productId}`;
-        const cloned = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken);
-        const { repoPath } = cloned;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, owner, repo, githubToken));
         const branch = options.branch ?? detectDefaultBranch(repoPath);
         logInfo(`Syncing ${owner}/${repo} to branch ${branch}`);
         syncRepoToRef(repoPath, { branch }, githubToken);
@@ -70,6 +71,7 @@ export async function scanForSmells(options) {
                         lastScannedAt: new Date().toISOString(),
                         lastError: undefined,
                     });
+                    scanSucceeded = true;
                     return {
                         status: 'success',
                         message: 'No changes since last scan',
@@ -92,6 +94,7 @@ export async function scanForSmells(options) {
                 lastScannedAt: new Date().toISOString(),
                 lastError: undefined,
             });
+            scanSucceeded = true;
             return {
                 status: 'success',
                 message: 'HEAD unchanged since last scan',
@@ -201,6 +204,7 @@ export async function scanForSmells(options) {
             lastError: undefined,
         });
         const droppedCount = droppedCategories.reduce((acc, d) => acc + d.count, 0);
+        scanSucceeded = true;
         return {
             status: 'success',
             message: `Filed ${created} of ${filteredSmells.length} candidate smells (${droppedCount} dropped by category filter; ${deferredBugs.length} deferred to bugs, ${deferredFeatures.length} to features)`,
@@ -222,6 +226,9 @@ export async function scanForSmells(options) {
         };
     }
     finally {
+        if (scanSucceeded) {
+            cleanupIssueRepo(repoPath);
+        }
         lock.release();
     }
 }

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

@@ -1,6 +1,6 @@
 /* eslint-disable max-lines -- orchestration module with test execution, result processing, and report generation */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { updateIssueStatus } from '../../api/issues/index.js';
+import { setPhaseState } from '../../api/issues/index.js';
 import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
 import { DEFAULT_MODEL } from '../../constants.js';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -279,11 +279,21 @@ async function saveTestResults(issueId, testStatus, structuredTestResult, lastAs
     if (verbose) {
         logInfo('Saving test results...');
     }
-    const statusSaved = await updateIssueStatus({
-        issueId,
-        status: testStatus,
-        verbose,
-    });
+    // testStatus is 'testing_passed' | 'testing_failed'. Under the 2D model
+    // both map to a single phase-state update on functional_testing —
+    // 'completed' for passed, 'failed' for failed. issues.status stays
+    // 'in_progress'; humans decide when to ship.
+    const phaseState = testStatus === 'testing_passed' ? 'completed' : 'failed';
+    let statusSaved = true;
+    try {
+        await setPhaseState(issueId, 'functional_testing', phaseState, verbose);
+    }
+    catch (err) {
+        statusSaved = false;
+        if (verbose) {
+            logError(`Direct setPhaseState failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     if (!statusSaved) {
         if (verbose) {
             logInfo('Direct status update failed, trying HTTP fallback...');
@@ -326,7 +336,6 @@ async function saveTestResults(issueId, testStatus, structuredTestResult, lastAs
     }
     return testReportResult;
 }
-// eslint-disable-next-line complexity
 export const runFunctionalTesting = async (options, config, checklistContext) => {
     const { issueId, verbose } = options;
     if (verbose) {
@@ -428,12 +437,13 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
     catch (error) {
         logError(`Functional testing failed: ${error instanceof Error ? error.message : String(error)}`);
         try {
-            const errorSaved = await updateIssueStatus({
-                issueId,
-                status: 'testing_failed',
-                verbose,
-            });
-            if (!errorSaved) {
+            await setPhaseState(issueId, 'functional_testing', 'failed', verbose);
+        }
+        catch (rpcErr) {
+            if (verbose) {
+                logError(`Direct setPhaseState failed (${rpcErr instanceof Error ? rpcErr.message : String(rpcErr)}); trying HTTP fallback...`);
+            }
+            try {
                 await saveFunctionalTestResultsWithRetry({
                     issueId,
                     testStatus: 'testing_failed',
@@ -441,10 +451,10 @@ export const runFunctionalTesting = async (options, config, checklistContext) =>
                     verbose,
                 });
             }
-        }
-        catch (fallbackError) {
-            if (verbose) {
-                logError(`❌ Failed to save error status: ${fallbackError}`);
+            catch (fallbackError) {
+                if (verbose) {
+                    logError(`❌ Failed to save error status: ${fallbackError}`);
+                }
             }
         }
         return {

package/dist/phases/functional-testing/http-fallback.d.ts

@@ -5,6 +5,6 @@ interface SaveFunctionalTestResultsOptions {
     verbose?: boolean;
 }
 export declare function saveFunctionalTestResultsViaHttp(options: SaveFunctionalTestResultsOptions): Promise<boolean>;
-export declare function verifyTestStatusSaved(issueId: string, verbose?: boolean, expectedStatus?: string): Promise<boolean>;
+export declare function verifyTestStatusSaved(issueId: string, verbose?: boolean, expectedStatus?: SaveFunctionalTestResultsOptions['testStatus']): Promise<boolean>;
 export declare function saveFunctionalTestResultsWithRetry(options: SaveFunctionalTestResultsOptions, maxRetries?: number): Promise<boolean>;
 export {};

package/dist/phases/functional-testing/http-fallback.js

@@ -1,7 +1,18 @@
 import { getMcpServerUrl, getMcpToken } from '../../auth/auth-store.js';
 import { logError, logInfo } from '../../utils/logger.js';
+function legacyTestStatusToPhaseState(testStatus) {
+    switch (testStatus) {
+        case 'testing_in_progress':
+            return 'running';
+        case 'testing_passed':
+            return 'completed';
+        case 'testing_failed':
+            return 'failed';
+    }
+}
 export async function saveFunctionalTestResultsViaHttp(options) {
-    const { issueId, testStatus, testResults: _testResults, verbose } = options;
+    const { issueId, testStatus, verbose } = options;
+    const phaseState = legacyTestStatusToPhaseState(testStatus);
     try {
         if (verbose) {
             logInfo('🔄 Attempting to save functional test results via HTTP fallback...');
@@ -16,10 +27,11 @@ export async function saveFunctionalTestResultsViaHttp(options) {
             },
             body: JSON.stringify({
                 jsonrpc: '2.0',
-                method: 'issues/update',
+                method: 'issues/set_phase_state',
                 params: {
                     issue_id: issueId,
-                    status: testStatus,
+                    phase: 'functional_testing',
+                    state: phaseState,
                 },
                 id: Math.random().toString(36).substring(7),
             }),
@@ -32,7 +44,7 @@ export async function saveFunctionalTestResultsViaHttp(options) {
             throw new Error(data.error.message || 'HTTP call failed');
         }
         if (verbose) {
-            logInfo(`✅ Functional test results saved successfully via HTTP fallback (status: ${testStatus})`);
+            logInfo(`✅ Functional test results saved successfully via HTTP fallback (functional_testing → ${phaseState})`);
         }
         return true;
     }
@@ -73,29 +85,33 @@ export async function verifyTestStatusSaved(issueId, verbose, expectedStatus) {
             throw new Error(data.error.message || 'Verification failed');
         }
         const issue = data.result?.issues?.[0];
-        const actualTestStatus = issue?.status;
-        if (expectedStatus && actualTestStatus) {
-            const statusMatches = actualTestStatus === expectedStatus;
+        // Look up functional_testing phase status in the workflow array
+        const workflow = issue?.workflow;
+        const ftPhase = workflow?.find((p) => p.phase === 'functional_testing');
+        const actualPhaseState = ftPhase?.status;
+        if (expectedStatus && actualPhaseState) {
+            const expected = legacyTestStatusToPhaseState(expectedStatus);
+            const matches = actualPhaseState === expected;
             if (verbose) {
-                if (statusMatches) {
-                    logInfo(`✅ Test status verified - matches expected: ${expectedStatus}`);
+                if (matches) {
+                    logInfo(`✅ Test phase verified - functional_testing.status=${expected}`);
                 }
                 else {
-                    logInfo(`⚠️  Test status exists but differs from expected: ${actualTestStatus} vs ${expectedStatus}`);
+                    logInfo(`⚠️  Test phase exists but differs - got ${actualPhaseState}, expected ${expected}`);
                 }
             }
-            return statusMatches;
+            return matches;
         }
-        const hasTestStatus = actualTestStatus && actualTestStatus !== 'untested';
+        const hasTestPhase = !!actualPhaseState;
         if (verbose) {
-            if (hasTestStatus) {
-                logInfo(`✅ Test status verified - current status: ${actualTestStatus}`);
+            if (hasTestPhase) {
+                logInfo(`✅ Test phase verified - functional_testing.status=${actualPhaseState}`);
             }
             else {
-                logInfo('⚠️  Test status verification failed - status is untested or not found');
+                logInfo('⚠️  Test phase verification failed - functional_testing not in workflow');
             }
         }
-        return hasTestStatus;
+        return hasTestPhase;
     }
     catch (error) {
         if (verbose) {

package/dist/phases/functional-testing/mcp-server.d.ts

@@ -1 +1,9 @@
-export declare const createFunctionalTestingMcpServer: () => import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;
+/**
+ * Functional-testing MCP server — CLI entry point.
+ *
+ * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
+ * `callMcpEndpoint` transport into the `ToolDeps` shape and reads the
+ * legacy env-var credential overrides into the deps `context`.
+ */
+import type { McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+export declare const createFunctionalTestingMcpServer: () => McpSdkServerConfigWithInstance;

package/dist/phases/functional-testing/mcp-server.js

@@ -1,132 +1,13 @@
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
-import { logError } from '../../utils/logger.js';
-// Create an SDK MCP server with custom tools for functional testing
-export const createFunctionalTestingMcpServer = () => {
-    return createSdkMcpServer({
-        name: 'edsger-functional-testing-mcp',
-        version: '1.0.0',
-        tools: [
-            tool('get_issue_testing_info', 'Get comprehensive issue information for functional testing including product, user stories, test cases, and technical design', {
-                issue_id: z
-                    .string()
-                    .describe('Issue ID to get testing information for'),
-            }, async (args) => {
-                try {
-                    // Get issue details
-                    const issueResult = (await callMcpEndpoint('issues/get', {
-                        issue_id: args.issue_id,
-                    }));
-                    if (!issueResult.issues || issueResult.issues.length === 0) {
-                        throw new Error('Issue not found');
-                    }
-                    const issue = issueResult.issues[0];
-                    // Get product details
-                    const productResult = (await callMcpEndpoint('resources/read', {
-                        uri: `product://${issue.product_id}`,
-                    }));
-                    const productText = productResult.contents?.[0]?.text || '{}';
-                    let productInfo;
-                    try {
-                        productInfo = JSON.parse(productText);
-                    }
-                    catch {
-                        productInfo = {
-                            id: issue.product_id,
-                            name: 'Unknown Product',
-                        };
-                    }
-                    // Get user stories
-                    const userStoriesResult = (await callMcpEndpoint('user_stories/list', { issue_id: args.issue_id }));
-                    // Get test cases
-                    const testCasesResult = (await callMcpEndpoint('test_cases/list', {
-                        issue_id: args.issue_id,
-                    }));
-                    const testingInfo = {
-                        issue,
-                        product: productInfo,
-                        user_stories: userStoriesResult.user_stories || [],
-                        test_cases: testCasesResult.test_cases || [],
-                        technical_design: issue.technical_design || null,
-                        current_test_status: issue.status || 'backlog',
-                    };
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify(testingInfo, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    logError(`Error in get_issue_testing_info: ${error}`);
-                    throw error;
-                }
-            }),
-            tool('update_test_status', 'Update the functional test status of an issue', {
-                issue_id: z.string().describe('Issue ID to update'),
-                test_status: z
-                    .enum(['testing_in_progress', 'testing_passed', 'testing_failed'])
-                    .describe('New test status'),
-                test_results: z
-                    .string()
-                    .optional()
-                    .describe('Optional test results or error details'),
-            }, async (args) => {
-                try {
-                    const result = await callMcpEndpoint('issues/update', {
-                        issue_id: args.issue_id,
-                        status: args.test_status,
-                    });
-                    return {
-                        content: [
-                            {
-                                type: 'text',
-                                text: JSON.stringify({
-                                    success: true,
-                                    issue_id: args.issue_id,
-                                    test_status: args.test_status,
-                                    test_results: args.test_results || null,
-                                    message: `Issue test status updated to: ${args.test_status}`,
-                                    result,
-                                }, null, 2),
-                            },
-                        ],
-                    };
-                }
-                catch (error) {
-                    logError(`Error updating test status: ${error}`);
-                    throw error;
-                }
-            }),
-            tool('get_environment_config', 'Get testing environment configuration including login credentials', {
-                environment: z
-                    .string()
-                    .optional()
-                    .default('testing')
-                    .describe('Environment name (testing, staging, production)'),
-            }, (args) => {
-                // Get environment variables for testing configuration
-                const testingConfig = {
-                    environment: args.environment || 'testing',
-                    login_username: process.env.TESTING_LOGIN_USERNAME || '',
-                    login_password: process.env.TESTING_LOGIN_PASSWORD || '',
-                };
-                // Validate required configuration
-                if (!testingConfig.login_username || !testingConfig.login_password) {
-                    throw new Error('Testing credentials not configured. Set TESTING_LOGIN_USERNAME and TESTING_LOGIN_PASSWORD environment variables.');
-                }
-                return Promise.resolve({
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(testingConfig, null, 2),
-                        },
-                    ],
-                });
-            }),
-        ],
-    });
-};
+/**
+ * Functional-testing MCP server — CLI entry point.
+ *
+ * Tool implementations live in `edsger-tools`. This shim adapts the CLI's
+ * `callMcpEndpoint` transport into the `ToolDeps` shape and reads the
+ * legacy env-var credential overrides into the deps `context`.
+ */
+import { createFunctionalTestingMcpServer as createFunctionalTestingMcpServerCore } from 'edsger-tools';
+import { getToolDeps } from '../../tools/bootstrap.js';
+export const createFunctionalTestingMcpServer = () => createFunctionalTestingMcpServerCore(getToolDeps(false, {
+    testingLoginUsername: process.env.TESTING_LOGIN_USERNAME,
+    testingLoginPassword: process.env.TESTING_LOGIN_PASSWORD,
+}));

package/dist/phases/growth-analysis/agent.js

@@ -38,7 +38,6 @@ function userMessage(content) {
 async function* prompt(analysisPrompt) {
     yield userMessage(analysisPrompt);
 }
-// eslint-disable-next-line complexity -- agent loop with message type handling
 export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, config, verbose, cwd) {
     let lastAssistantResponse = '';
     let structuredResult = null;
@@ -69,7 +68,8 @@ export async function executeGrowthAnalysisQuery(currentPrompt, systemPrompt, co
                     logDebug(`${content.text}`, verbose);
                 }
                 else if (content.type === 'tool_use') {
-                    const desc = content.input?.description || content.input?.command || 'Running...';
+                    const input = (content.input ?? {});
+                    const desc = input.description ?? input.command ?? 'Running...';
                     logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
                 }
             }

package/dist/phases/growth-analysis/index.js

@@ -2,7 +2,7 @@ import { getGitHubConfigByProduct } from '../../api/github.js';
 import { saveGrowthAnalysis, updateGrowthAnalysis } from '../../api/growth.js';
 import { generateGrowthVideo, } from '../../services/video/index.js';
 import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
 import { executeGrowthAnalysisQuery } from './agent.js';
 import { prepareGrowthAnalysisContext } from './context.js';
 import { createGrowthAnalysisSystemPrompt } from './prompts.js';
@@ -49,15 +49,15 @@ contentSuggestions) {
     }
     return plans;
 }
-// eslint-disable-next-line complexity
 export const analyseGrowth = async (options, config) => {
     const { productId, verbose, guidance, analysisId } = options;
     if (verbose) {
         logInfo(`Starting growth analysis for product ID: ${productId}`);
     }
+    let repoCwd;
+    let analysisSucceeded = false;
     try {
         // Clone product repo if GitHub is configured
-        let repoCwd;
         try {
             const githubConfig = await getGitHubConfigByProduct(productId, verbose);
             if (githubConfig.configured &&
@@ -174,6 +174,7 @@ export const analyseGrowth = async (options, config) => {
                     : {}),
             };
         });
+        analysisSucceeded = true;
         return {
             productId,
             status: 'success',
@@ -193,6 +194,11 @@ export const analyseGrowth = async (options, config) => {
             contentSuggestions: [],
         };
     }
+    finally {
+        if (analysisSucceeded) {
+            cleanupIssueRepo(repoCwd);
+        }
+    }
 };
 /**
  * Run async tasks with a concurrency limit.