vibeman 0.0.1 → 0.0.2

package/dist/runtime/api/agent/agent-service.d.ts

@@ -64,6 +64,7 @@ export declare class AgentService extends EventEmitter {
             attempt?: number;
         };
         providerOverride?: Partial<ResolvedProvider>;
+        workflowConfig?: import('../types/index.js').VibingConfig;
     }): Promise<string>;
     /**
      * Build an appended system prompt with rerun context (reason, logs, failed checks)
@@ -97,13 +98,18 @@ export declare class AgentService extends EventEmitter {
         type: string;
         priority: string;
         content: string;
+        title?: string;
         executionId: string;
         selectedModel?: string;
     }>;
     /**
      * Perform AI code review of changes in a worktree
      */
-    aiReviewCode(taskId: string, reviewContext?: string, overrides?: Partial<ResolvedProvider>): Promise<{
+    aiReviewCode(taskId: string, reviewContext?: string, options?: {
+        overrides?: Partial<ResolvedProvider>;
+        executionId?: string;
+        workflowId?: string;
+    }): Promise<{
         executionId: string;
         reviewSummary: string;
         recommendations: string[];
@@ -114,19 +120,11 @@ export declare class AgentService extends EventEmitter {
      */
     aiMerge(taskId: string, options?: {
         baseBranch?: string;
-    }, overrides?: Partial<ResolvedProvider>): Promise<{
-        executionId: string;
-    }>;
-    /**
-     * Compatibility alias for aiReviewCode
-     * @deprecated Use aiReviewCode instead
-     * TODO: migrate UI to use aiReviewCode directly and remove this
-     */
-    reviewCode(taskId: string, reviewContext?: string, overrides?: Partial<ResolvedProvider>): Promise<{
+        overrides?: Partial<ResolvedProvider>;
+        executionId?: string;
+        workflowId?: string;
+    }): Promise<{
         executionId: string;
-        reviewSummary: string;
-        recommendations: string[];
-        qualityScore: number;
     }>;
     /**
      * Get persistent execution logs

package/dist/runtime/api/agent/agent-service.js

@@ -325,8 +325,8 @@ export class AgentService extends EventEmitter {
         catch (error) {
             log.error('Failed to create worktree, using main directory', error, 'agent-service');
         }
-        // Generate task prompt
-        const prompt = await this.promptService.generateTaskPrompt(task);
+        // Generate task prompt with workflow configuration for dynamic instructions
+        const prompt = await this.promptService.generateTaskPrompt(task, options?.workflowConfig);
         // Build system prompt - use rerun context if available, otherwise base prompt
         let appendSystemPrompt;
         if (options?.rerunContext) {
@@ -349,6 +349,7 @@ export class AgentService extends EventEmitter {
             tools: this.defaultTools.execute_task,
             timeout: 30 * 60 * 1000,
             appendSystemPrompt,
+            dangerouslyBypassApprovalsAndSandbox: true,
             executionId,
             metadata: {
                 operation: 'execute_task',
@@ -538,6 +539,7 @@ export class AgentService extends EventEmitter {
                 appendSystemPrompt: this.systemPrompts.improve_task,
                 tools: this.defaultTools.improve_task,
                 timeout: 5 * 60 * 1000,
+                dangerouslyBypassApprovalsAndSandbox: false,
                 executionId: finalExecutionId,
                 metadata: {
                     operation: 'improve_task',
@@ -559,7 +561,7 @@ export class AgentService extends EventEmitter {
     /**
      * Perform AI code review of changes in a worktree
      */
-    async aiReviewCode(taskId, reviewContext, overrides) {
+    async aiReviewCode(taskId, reviewContext, options) {
         const task = this.taskService.getTask(taskId);
         if (!task) {
             throw new Error(`Task ${taskId} not found`);
@@ -568,7 +570,7 @@ export class AgentService extends EventEmitter {
         if (!worktree) {
             throw new Error(`No worktree found for task ${taskId}`);
         }
-        const executionId = generateId('review');
+        const executionId = options?.executionId ?? generateId('review');
         try {
             // Pre-register execution for streaming/persistence
             if (!this.executionRegistry.has(executionId)) {
@@ -586,7 +588,7 @@ export class AgentService extends EventEmitter {
                     logs: [],
                     workingDirectory: this.projectRoot,
                 };
-                await this.logPersistence.startExecution(execRec);
+                await this.logPersistence.startExecution(execRec, options?.workflowId);
             }
             // Generate review prompt
             const reviewPrompt = await this.promptService.generateReviewPrompt(task, worktree, reviewContext);
@@ -606,7 +608,7 @@ export class AgentService extends EventEmitter {
                     operation: 'ai_codereview',
                     taskId,
                 },
-            }, overrides);
+            }, options?.overrides);
             // Parse review result
             const review = this.parseReviewResult(result);
             const payload = { executionId, ...review };
@@ -627,7 +629,7 @@ export class AgentService extends EventEmitter {
     /**
      * Perform AI-assisted merge of a task's worktree into the base project
      */
-    async aiMerge(taskId, options, overrides) {
+    async aiMerge(taskId, options) {
         const task = this.taskService.getTask(taskId);
         if (!task) {
             throw new Error(`Task ${taskId} not found`);
@@ -636,14 +638,15 @@ export class AgentService extends EventEmitter {
         if (!worktree) {
             throw new Error(`No worktree found for task ${taskId}`);
         }
-        const executionId = generateId('merge');
+        const executionId = options?.executionId ?? generateId('merge');
+        const workingDirectory = worktree.path || this.projectRoot;
         try {
             // Pre-register execution for streaming/persistence
             if (!this.executionRegistry.has(executionId)) {
                 const startTime = new Date().toISOString();
                 this.executionRegistry.set(executionId, {
                     taskId,
-                    workingDirectory: this.projectRoot,
+                    workingDirectory,
                     startTime,
                 });
                 const execRec = {
@@ -652,21 +655,21 @@ export class AgentService extends EventEmitter {
                     status: 'pending',
                     startTime,
                     logs: [],
-                    workingDirectory: this.projectRoot,
+                    workingDirectory,
                 };
-                await this.logPersistence.startExecution(execRec);
+                await this.logPersistence.startExecution(execRec, options?.workflowId);
             }
             // Generate merge prompt
             const mergePrompt = await this.promptService.generateAIMergePrompt(task, worktree, options?.baseBranch);
             void this.logPersistence.logMessage(executionId, 'Merge prompt prepared', 'info', {
                 prompt: mergePrompt,
-                options: { workingDirectory: this.projectRoot, tools: this.defaultTools.ai_merge },
+                options: { workingDirectory, tools: this.defaultTools.ai_merge },
                 taskId,
                 baseBranch: options?.baseBranch,
             });
             // Execute merge with AI
             await this.executeWithRouting('ai_merge', mergePrompt, {
-                workingDirectory: this.projectRoot,
+                workingDirectory,
                 appendSystemPrompt: this.systemPrompts.ai_merge,
                 tools: this.defaultTools.ai_merge,
                 timeout: 15 * 60 * 1000,
@@ -676,29 +679,13 @@ export class AgentService extends EventEmitter {
                     taskId,
                     baseBranch: options?.baseBranch,
                 },
-            }, overrides);
-            // Ensure registry exists for lookups (no-op otherwise)
-            if (!this.executionRegistry.has(executionId)) {
-                this.executionRegistry.set(executionId, {
-                    taskId,
-                    workingDirectory: this.projectRoot,
-                    startTime: new Date().toISOString(),
-                });
-            }
+            }, options?.overrides);
             return { executionId };
         }
         catch (error) {
             throw new Error(`AI merge failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    /**
-     * Compatibility alias for aiReviewCode
-     * @deprecated Use aiReviewCode instead
-     * TODO: migrate UI to use aiReviewCode directly and remove this
-     */
-    async reviewCode(taskId, reviewContext, overrides) {
-        return this.aiReviewCode(taskId, reviewContext, overrides);
-    }
     /**
      * Get persistent execution logs
      */
@@ -843,8 +830,15 @@ export class AgentService extends EventEmitter {
         catch {
             // best effort; ignore if settings unavailable
         }
-        let lastError = null;
         const providersToTry = [resolved.provider, ...(resolved.fallbacks || [])];
+        // Ensure Codex executes with write permissions when it is in the routing set.
+        // Some overrides may omit the flag, so default it on for task execution.
+        if (operation === 'execute_task' &&
+            providersToTry.includes('codex') &&
+            executionOptions.dangerouslyBypassApprovalsAndSandbox === undefined) {
+            executionOptions.dangerouslyBypassApprovalsAndSandbox = true;
+        }
+        let lastError = null;
         for (let i = 0; i < providersToTry.length; i++) {
             const provider = providersToTry[i];
             const isLastProvider = i === providersToTry.length - 1;

package/dist/runtime/api/agent/ai-providers/claude-code-adapter.d.ts

@@ -43,7 +43,7 @@ export declare class ClaudeCodeAdapter implements AIProvider {
      */
     detectAvailableModels(): Promise<ModelInfo[]>;
     /**
-     * Validate Claude Code setup
+     * Validate Claude Code setup using enhanced detection
      */
     validateSetup(): Promise<ProviderStatus>;
     /**
@@ -55,7 +55,7 @@ export declare class ClaudeCodeAdapter implements AIProvider {
      */
     private mapToClaudeOptions;
     /**
-     * Resolve Claude CLI executable path
+     * Resolve Claude CLI executable path using enhanced detection
      */
     private getClaudeExecutablePath;
 }

package/dist/runtime/api/agent/ai-providers/claude-code-adapter.js

@@ -3,10 +3,9 @@
  * Implements AIProvider interface for Claude Code SDK
  */
 import { query } from '@anthropic-ai/claude-code';
-import path from 'path';
-import os from 'os';
 import { generateId } from '../../lib/id-generator.js';
 import { getSettingsService } from '../../settings-service.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
 /**
  * Claude Code Adapter
  * Wraps the Claude Code SDK to implement the AIProvider interface
@@ -21,7 +20,7 @@ export class ClaudeCodeAdapter {
      * Execute a prompt using Claude Code SDK
      */
     async *execute(prompt, options) {
-        const claudeOptions = this.mapToClaudeOptions(options);
+        const claudeOptions = await this.mapToClaudeOptions(options);
         const co = claudeOptions;
         const startTime = Date.now();
         let sessionId;
@@ -249,30 +248,19 @@ export class ClaudeCodeAdapter {
         ];
     }
     /**
-     * Validate Claude Code setup
+     * Validate Claude Code setup using enhanced detection
      */
     async validateSetup() {
         try {
-            const claudePath = this.getClaudeExecutablePath();
-            const fs = await import('fs/promises');
-            // Check if Claude executable exists
-            try {
-                await fs.access(claudePath);
-            }
-            catch {
-                // Try to execute claude directly (might be in PATH)
-                const { execSync } = await import('child_process');
-                try {
-                    execSync('claude --version', { stdio: 'ignore' });
-                }
-                catch {
-                    return {
-                        available: false,
-                        error: 'Claude CLI not found. Please install Claude Code CLI.',
-                        models: [],
-                        capabilities: this.getCapabilities(),
-                    };
-                }
+            const detectionService = getProviderDetectionService();
+            const result = await detectionService.detectProvider('claude-code');
+            if (!result.found) {
+                return {
+                    available: false,
+                    error: result.error || 'Claude CLI not found. Please install Claude Code CLI.',
+                    models: [],
+                    capabilities: this.getCapabilities(),
+                };
             }
             const models = await this.detectAvailableModels();
             return {
@@ -307,11 +295,11 @@ export class ClaudeCodeAdapter {
     /**
      * Map ExecutionOptions to Claude Code Options
      */
-    mapToClaudeOptions(options) {
+    async mapToClaudeOptions(options) {
         const claudeOptions = {
             cwd: options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd(),
             model: options?.model || this.config.defaultModel,
-            pathToClaudeCodeExecutable: this.getClaudeExecutablePath(),
+            pathToClaudeCodeExecutable: await this.getClaudeExecutablePath(),
         };
         // Map temperature
         if (options?.temperature !== undefined) {
@@ -342,18 +330,20 @@ export class ClaudeCodeAdapter {
         return claudeOptions;
     }
     /**
-     * Resolve Claude CLI executable path
+     * Resolve Claude CLI executable path using enhanced detection
      */
-    getClaudeExecutablePath() {
-        // Highest precedence: explicit env var (documented in README)
-        const envPath = process.env.VIBEMAN_CLAUDE_BIN;
-        if (envPath && envPath.trim()) {
-            return envPath.trim();
-        }
+    async getClaudeExecutablePath() {
+        // Highest precedence: explicit config option
         if (this.config.claudeBinPath) {
             return this.config.claudeBinPath;
         }
-        // Check settings first
+        // Use enhanced detection service
+        const detectionService = getProviderDetectionService();
+        const result = await detectionService.detectProvider('claude-code');
+        if (result.found && result.path) {
+            return result.path;
+        }
+        // Fallback: try old settings-based approach for backwards compatibility
         const settingsBinPath = (() => {
             try {
                 const svc = getSettingsService();
@@ -367,7 +357,6 @@ export class ClaudeCodeAdapter {
         if (settingsBinPath?.trim()) {
             return settingsBinPath.trim();
         }
-        // Default to local installation
-        return path.join(os.homedir(), '.claude', 'local', 'claude');
+        return 'claude';
     }
 }

package/dist/runtime/api/agent/ai-providers/codex-cli-provider.js

@@ -4,6 +4,7 @@
  */
 import { spawn } from 'child_process';
 import { getSettingsService } from '../../settings-service.js';
+import { getProviderDetectionService } from '../../lib/provider-detection.js';
 import { logger } from '../../lib/logger.js';
 export class CodexCliProvider {
     constructor(config = {}) {
@@ -11,10 +12,16 @@ export class CodexCliProvider {
         this.name = 'codex';
         this.displayName = 'Codex CLI';
     }
-    resolveExecutable() {
+    async resolveExecutable() {
         if (this.config.codexBinPath)
             return this.config.codexBinPath;
-        // Check settings first
+        // Use enhanced detection service
+        const detectionService = getProviderDetectionService();
+        const result = await detectionService.detectProvider('codex');
+        if (result.found && result.path) {
+            return result.path;
+        }
+        // Fallback: try old settings-based approach for backwards compatibility
         const settingsBinPath = (() => {
             try {
                 const svc = getSettingsService();
@@ -51,8 +58,19 @@ export class CodexCliProvider {
         const images = (options?.images || []).filter(Boolean);
         const effort = options?.effort;
         const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
+        const systemPrompt = options?.systemPrompt?.trim();
+        const appendSystemPrompt = options?.appendSystemPrompt?.trim();
+        const promptSegments = [];
+        if (systemPrompt) {
+            promptSegments.push(systemPrompt);
+        }
+        if (appendSystemPrompt) {
+            promptSegments.push(appendSystemPrompt);
+        }
+        promptSegments.push(prompt);
+        const effectivePrompt = promptSegments.join('\n\n');
         // Build argv for `codex exec` (non-interactive automation mode)
-        const argv = ['exec', prompt];
+        const argv = ['exec', effectivePrompt];
         if (model) {
             argv.push('--model', model);
         }
@@ -63,7 +81,10 @@ export class CodexCliProvider {
         if (images.length) {
             argv.push('--image', images.join(','));
         }
-        const cmd = this.resolveExecutable();
+        if (options?.dangerouslyBypassApprovalsAndSandbox) {
+            argv.push('--dangerously-bypass-approvals-and-sandbox');
+        }
+        const cmd = await this.resolveExecutable();
         const child = spawn(cmd, argv, {
             cwd,
             env: { ...process.env },
@@ -81,8 +102,17 @@ export class CodexCliProvider {
         yield {
             type: 'system',
             timestamp: new Date().toISOString(),
-            content: `Running: ${cmd} ${argv.map((a) => (a.includes(' ') ? '"' + a + '"' : a)).join(' ')} (cwd=${cwd})`,
-            metadata: { provider: this.name, images, effort },
+            content: `Running: ${cmd} ${argv
+                .map((a) => (a.includes(' ') ? '"' + a + '"' : a))
+                .join(' ')} (cwd=${cwd})`,
+            metadata: {
+                provider: this.name,
+                images,
+                effort,
+                systemPrompt,
+                appendSystemPrompt,
+                dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
+            },
         };
         let stdoutBuf = '';
         // let stderrBuf = '';
@@ -243,13 +273,17 @@ export class CodexCliProvider {
     }
     async validateSetup() {
         try {
-            const bin = this.resolveExecutable();
-            // Try to spawn `codex --help` quickly to validate presence
-            const child = spawn(bin, ['--help'], { stdio: 'ignore' });
-            await new Promise((resolve, reject) => {
-                child.once('error', reject);
-                child.once('close', () => resolve());
-            });
+            const detectionService = getProviderDetectionService();
+            const result = await detectionService.detectProvider('codex');
+            if (!result.found) {
+                return {
+                    available: false,
+                    error: result.error ||
+                        'Codex CLI not found. Install from https://github.com/openai/codex (see Getting Started: CLI usage).',
+                    models: [],
+                    capabilities: this.getCapabilities(),
+                };
+            }
             return {
                 available: true,
                 models: await this.detectAvailableModels(),
@@ -260,7 +294,7 @@ export class CodexCliProvider {
             logger.error(error);
             return {
                 available: false,
-                error: 'Codex CLI not found. Install from https://github.com/openai/codex (see Getting Started: CLI usage).',
+                error: error instanceof Error ? error.message : String(error),
                 models: [],
                 capabilities: this.getCapabilities(),
             };

package/dist/runtime/api/agent/ai-providers/types.d.ts

@@ -45,6 +45,8 @@ export interface ExecutionOptions {
     images?: string[];
     /** Optional effort hint for reasoning presets (e.g., 'minimal'|'low'|'medium'|'high'); informational only */
     effort?: string;
+    /** Enable Codex CLI sandbox bypass flag when running automation that must edit files */
+    dangerouslyBypassApprovalsAndSandbox?: boolean;
 }
 /**
  * Message types for streaming execution

package/dist/runtime/api/agent/codex-cli-provider.test.js

@@ -55,6 +55,43 @@ describe('CodexCliProvider (mocked)', () => {
         expect(modelIdx).toBeGreaterThan(-1);
         expect(captured[1][modelIdx + 1]).toBe('gpt-5');
     });
+    it('prepends system prompts and toggles sandbox bypass flag', async () => {
+        vi.resetModules();
+        vi.doMock('child_process', () => {
+            let captured = [];
+            return {
+                __captured: () => captured,
+                spawn: (cmd, args, opts) => {
+                    captured = [cmd, args, opts];
+                    const { EventEmitter } = require('events');
+                    const stdout = new EventEmitter();
+                    const proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Done\n')), 5);
+                    setTimeout(() => proc.emit('exit', 0, null), 10);
+                    return proc;
+                },
+            };
+        });
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider();
+        const iter = provider.execute('Implement feature', {
+            workingDirectory: '/tmp/project',
+            systemPrompt: 'Base system prompt',
+            appendSystemPrompt: 'Additional guidance',
+            dangerouslyBypassApprovalsAndSandbox: true,
+        });
+        for await (const _ of iter) {
+            // drain iterator
+        }
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        expect(captured[1][1]).toContain('Base system prompt');
+        expect(captured[1][1]).toContain('Additional guidance');
+        const bypassIdx = captured[1].indexOf('--dangerously-bypass-approvals-and-sandbox');
+        expect(bypassIdx).toBeGreaterThan(-1);
+        expect(captured[1][bypassIdx + 1]).toBeUndefined();
+    });
 });
 // Real integration (opt-in)
 (USE_REAL ? describe : describe.skip)('CodexCliProvider (real CLI)', () => {

package/dist/runtime/api/agent/parsers.d.ts

@@ -7,6 +7,7 @@ export declare function parseImprovementResult(result: string, originalData: {
     type: string;
     priority: string;
     content: string;
+    title?: string;
 };
 export declare function parseReviewResult(result: string): {
     reviewSummary: string;

package/dist/runtime/api/agent/parsers.js

@@ -60,9 +60,10 @@ function extractLastValidJson(text) {
  */
 function parseJsonManually(jsonStr) {
     try {
-        // Extract type and priority with simple regex (these are usually well-formed)
+        // Extract type, priority and title with simple regex (these are usually well-formed)
         const typeMatch = jsonStr.match(/"type":\s*"([^"]+)"/);
         const priorityMatch = jsonStr.match(/"priority":\s*"([^"]+)"/);
+        const titleMatch = jsonStr.match(/"title":\s*"([^"]+)"/);
         // For content, find the start and extract everything until the closing brace
         const contentStart = jsonStr.indexOf('"content":');
         if (contentStart === -1)
@@ -103,11 +104,16 @@ function parseJsonManually(jsonStr) {
                 .replace(/\\t/g, '\t')
                 .replace(/\\"/g, '"')
                 .replace(/\\\\/g, '\\');
-            return {
+            const result = {
                 type: typeMatch[1],
                 priority: priorityMatch[1],
                 content: content,
             };
+            // Add title if found
+            if (titleMatch) {
+                result.title = titleMatch[1];
+            }
+            return result;
         }
         return null;
     }
@@ -117,6 +123,24 @@ function parseJsonManually(jsonStr) {
         return null;
     }
 }
+/**
+ * Extract title from markdown content and remove it from content
+ * Returns { title: string | null, cleanedContent: string }
+ */
+function extractTitleFromContent(content) {
+    if (!content || typeof content !== 'string') {
+        return { title: null, cleanedContent: content };
+    }
+    // Look for H1 heading at the start of content (with optional whitespace)
+    const h1Match = content.match(/^\s*#\s+([^\n\r]+)/);
+    if (h1Match) {
+        const title = h1Match[1].trim();
+        // Remove the H1 heading from content
+        const cleanedContent = content.replace(/^\s*#\s+[^\n\r]+\s*\n?/, '').trim();
+        return { title, cleanedContent };
+    }
+    return { title: null, cleanedContent: content };
+}
 export function parseImprovementResult(result, originalData) {
     try {
         const jsonBlock = extractLastValidJson(result);
@@ -130,13 +154,31 @@ export function parseImprovementResult(result, originalData) {
                     const validPriorities = ['high', 'medium', 'low'];
                     const normalizedType = String(parsed.type).toLowerCase();
                     const normalizedPriority = String(parsed.priority).toLowerCase();
-                    return {
+                    // Extract title from JSON if present, otherwise from content
+                    let finalTitle;
+                    let finalContent = String(parsed.content).trim();
+                    if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
+                        finalTitle = parsed.title.trim();
+                    }
+                    else {
+                        // Try to extract title from content
+                        const { title, cleanedContent } = extractTitleFromContent(finalContent);
+                        if (title) {
+                            finalTitle = title;
+                            finalContent = cleanedContent;
+                        }
+                    }
+                    const result = {
                         type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
                         priority: validPriorities.includes(normalizedPriority)
                             ? normalizedPriority
                             : originalData.priority,
-                        content: String(parsed.content).trim(),
+                        content: finalContent,
                     };
+                    if (finalTitle) {
+                        result.title = finalTitle;
+                    }
+                    return result;
                 }
             }
             catch (parseError) {
@@ -151,13 +193,31 @@ export function parseImprovementResult(result, originalData) {
                         const validPriorities = ['high', 'medium', 'low'];
                         const normalizedType = String(parsed.type).toLowerCase();
                         const normalizedPriority = String(parsed.priority).toLowerCase();
-                        return {
+                        // Extract title from parsed JSON if present, otherwise from content
+                        let finalTitle;
+                        let finalContent = String(parsed.content).trim();
+                        if (parsed.title && typeof parsed.title === 'string' && parsed.title.trim()) {
+                            finalTitle = parsed.title.trim();
+                        }
+                        else {
+                            // Try to extract title from content
+                            const { title, cleanedContent } = extractTitleFromContent(finalContent);
+                            if (title) {
+                                finalTitle = title;
+                                finalContent = cleanedContent;
+                            }
+                        }
+                        const result = {
                             type: validTypes.includes(normalizedType) ? normalizedType : originalData.type,
                             priority: validPriorities.includes(normalizedPriority)
                                 ? normalizedPriority
                                 : originalData.priority,
-                            content: String(parsed.content).trim(),
+                            content: finalContent,
                         };
+                        if (finalTitle) {
+                            result.title = finalTitle;
+                        }
+                        return result;
                     }
                 }
                 catch (secondError) {
@@ -171,11 +231,18 @@ export function parseImprovementResult(result, originalData) {
         const errMsg = error instanceof Error ? error.message : String(error);
         log.error('Failed to parse improvement result', { error: errMsg, result }, 'result-parsers');
     }
-    return {
+    // Fallback: try to extract title from the raw result content
+    const fallbackContent = result.trim() || originalData.content;
+    const { title: extractedTitle, cleanedContent } = extractTitleFromContent(fallbackContent);
+    const fallbackResult = {
         type: originalData.type,
         priority: originalData.priority,
-        content: result.trim() || originalData.content,
+        content: cleanedContent,
     };
+    if (extractedTitle) {
+        fallbackResult.title = extractedTitle;
+    }
+    return fallbackResult;
 }
 export function parseReviewResult(result) {
     try {