vibeman 0.0.1 → 0.0.3

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

@@ -2,7 +2,7 @@ import { EventEmitter } from 'events';
 import { Task, WorktreeInfo, AgentExecution, VibingPhase, QualityResults } from '../types/index.js';
 import { TaskService } from '../tasks/task-service.js';
 import { WorktreeService } from '../vcs/worktree-service.js';
-import { RoutingPolicyManager, type ResolvedProvider } from './routing-policy.js';
+import { RoutingPolicyManager, type RoutableOperation, type ResolvedProvider } from './routing-policy.js';
 export interface AgentExecutionUpdate {
     executionId: string;
     status: AgentExecution['status'];
@@ -38,11 +38,6 @@ export declare class AgentService extends EventEmitter {
     private getAgentConfig;
     private initialize;
     private setupEventForwarding;
-    /**
-     * Map core agent update to legacy format
-     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
-     */
-    private mapToLegacyUpdate;
     /**
      * Create a concise, human-readable line from a structured execution message
      */
@@ -62,8 +57,14 @@ export declare class AgentService extends EventEmitter {
             qualityResults?: QualityResults;
             lastLogs?: string[];
             attempt?: number;
+            aiReview?: {
+                summary?: string;
+                recommendations?: string[];
+                score?: 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
@@ -215,6 +213,7 @@ export declare class AgentService extends EventEmitter {
      * Resolve provider for specific operation with failover support
      */
     private resolveProviderForOperation;
+    previewProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
     /**
      * Execute with provider resolution and failover
      */

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

@@ -40,6 +40,7 @@ export class AgentService extends EventEmitter {
         // TODO: need to be more granular, based on the task type and the toolset available for the AI provider
         this.defaultTools = {
             execute_task: fullTools,
+            quality_checks: fullTools,
             improve_task: fullTools,
             code_review: fullTools,
             ai_merge: fullTools,
@@ -154,16 +155,6 @@ export class AgentService extends EventEmitter {
         this.promptService = new PromptService(this.projectRoot, this.taskService);
         // Initialize routing policy manager
         this.routingPolicyManager = new RoutingPolicyManager();
-        // Create example policy file if needed (guarded for mocked environments)
-        try {
-            const maybePromise = this.routingPolicyManager.createExamplePolicy?.();
-            if (maybePromise && typeof maybePromise.catch === 'function') {
-                maybePromise.catch((err) => log.warn('Failed to create example policy', err, 'agent-service'));
-            }
-        }
-        catch (err) {
-            log.warn('Failed to trigger example policy creation', err, 'agent-service');
-        }
         // Set up event forwarding
         this.setupEventForwarding();
         this.initialized = true;
@@ -219,23 +210,6 @@ export class AgentService extends EventEmitter {
             });
         });
     }
-    /**
-     * Map core agent update to legacy format
-     * TODO: remove this later in a separate task, need to migrate the UI to handle raw message streaming
-     */
-    mapToLegacyUpdate(data) {
-        const messages = this.coreAgentService
-            .getExecutionMessages(data.executionId)
-            .map((m) => this.summarizeMessage(m));
-        return {
-            executionId: data.executionId,
-            status: data.status ||
-                this.coreAgentService.getExecutionStatus(data.executionId)?.status ||
-                'running',
-            logs: messages,
-            error: data.error,
-        };
-    }
     /**
      * Create a concise, human-readable line from a structured execution message
      */
@@ -325,8 +299,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 +323,7 @@ export class AgentService extends EventEmitter {
             tools: this.defaultTools.execute_task,
             timeout: 30 * 60 * 1000,
             appendSystemPrompt,
+            dangerouslyBypassApprovalsAndSandbox: true,
             executionId,
             metadata: {
                 operation: 'execute_task',
@@ -403,6 +378,28 @@ export class AgentService extends EventEmitter {
                 }
             }
         }
+        const review = rerun.aiReview;
+        if (review) {
+            parts.push('AI code review feedback from previous attempt:');
+            if (typeof review.score === 'number') {
+                parts.push(`- Quality score: ${review.score}`);
+            }
+            if (review.summary) {
+                parts.push(`- Summary: ${review.summary}`);
+            }
+            const recs = Array.isArray(review.recommendations)
+                ? review.recommendations.filter((r) => typeof r === 'string' && r.trim().length)
+                : [];
+            if (recs.length) {
+                parts.push('Recommendations:');
+                for (const item of recs.slice(0, 5)) {
+                    parts.push(`  * ${item}`);
+                }
+                if (recs.length > 5) {
+                    parts.push(`  * ...and ${recs.length - 5} more recommendations`);
+                }
+            }
+        }
         parts.push('Instruction: Address the reasons above. Avoid repeating prior mistakes. Keep changes scoped and test thoroughly. ');
         return parts.join('\n');
     }
@@ -538,6 +535,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 +557,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 +566,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 +584,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 +604,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 +625,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 +634,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 +651,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 +675,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
      */
@@ -814,6 +797,9 @@ export class AgentService extends EventEmitter {
     async resolveProviderForOperation(operation, overrides) {
         return await this.routingPolicyManager.resolveProviderForOperation(operation, overrides);
     }
+    async previewProviderForOperation(operation, overrides) {
+        return await this.resolveProviderForOperation(operation, overrides);
+    }
     /**
      * Execute with provider resolution and failover
      */
@@ -828,6 +814,16 @@ export class AgentService extends EventEmitter {
             workingDirectory: options.workingDirectory,
             timeout: options.timeout,
         };
+        // Persist a clear log line indicating chosen provider/model for this operation
+        try {
+            const execId = options?.executionId;
+            if (execId) {
+                await this.logPersistence.logMessage(execId, `Using provider: ${resolved.provider}${resolved.model ? ` (model: ${resolved.model})` : ''}`, 'info', { operation, resolved });
+            }
+        }
+        catch {
+            // best-effort logging; ignore
+        }
         // Default maxTokens from settings when not provided (unlimited if omitted)
         try {
             if (executionOptions.maxTokens === undefined) {
@@ -843,8 +839,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.d.ts

@@ -15,6 +15,8 @@ export declare class CodexCliProvider implements AIProvider {
     readonly displayName = "Codex CLI";
     constructor(config?: CodexCliConfig);
     private resolveExecutable;
+    private normalizeReasoningEffort;
+    private resolveModelSpec;
     execute(prompt: string, options?: ExecutionOptions): AsyncIterableIterator<ExecutionMessage>;
     executeSync(prompt: string, options?: ExecutionOptions): Promise<{
         id: string;