vibeman 0.0.2 → 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,6 +57,11 @@ 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;
@@ -213,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
      */
@@ -404,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');
     }
@@ -801,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
      */
@@ -815,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) {

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;

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

@@ -37,26 +37,47 @@ export class CodexCliProvider {
         // Default to binary name (resolve via PATH)
         return 'codex';
     }
+    normalizeReasoningEffort(value) {
+        if (!value)
+            return undefined;
+        const normalized = value.toLowerCase();
+        if (normalized === 'minimal')
+            return 'low';
+        const allowed = ['low', 'medium', 'high'];
+        return allowed.includes(normalized)
+            ? normalized
+            : undefined;
+    }
+    resolveModelSpec(model, fallbackEffort) {
+        const fallback = this.normalizeReasoningEffort(fallbackEffort);
+        if (!model) {
+            return { reasoning: fallback };
+        }
+        const trimmed = model.trim();
+        const normalized = trimmed.toLowerCase();
+        const match = normalized.match(/^(gpt-5(?:-codex)?)(?:-(minimal|low|medium|high))?$/);
+        if (!match) {
+            return {
+                cliModel: trimmed,
+                requestedModel: trimmed,
+                reasoning: fallback,
+            };
+        }
+        const baseModel = match[1];
+        const reasoning = this.normalizeReasoningEffort(match[2]);
+        return {
+            cliModel: baseModel,
+            requestedModel: trimmed,
+            reasoning: reasoning ?? fallback,
+        };
+    }
     async *execute(prompt, options) {
         // Effective options
         const cwd = options?.workingDirectory || this.config.defaultWorkingDirectory || process.cwd();
-        const mapModel = (m) => {
-            if (!m)
-                return m;
-            // Normalize reasoning-effort variants to the canonical model id
-            // Users reported only `gpt-5` is selectable; variants are effort levels in the TUI.
-            const lower = m.toLowerCase();
-            if (lower === 'gpt-5-minimal' ||
-                lower === 'gpt-5-low' ||
-                lower === 'gpt-5-medium' ||
-                lower === 'gpt-5-high') {
-                return 'gpt-5';
-            }
-            return m;
-        };
-        const model = mapModel(options?.model || this.config.defaultModel);
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
+        const model = resolvedModel.cliModel;
         const images = (options?.images || []).filter(Boolean);
-        const effort = options?.effort;
+        const reasoningEffort = resolvedModel.reasoning;
         const timeoutMs = options?.timeout ?? this.config.defaultTimeoutMs ?? 10 * 60 * 1000; // 10m
         const systemPrompt = options?.systemPrompt?.trim();
         const appendSystemPrompt = options?.appendSystemPrompt?.trim();
@@ -74,6 +95,9 @@ export class CodexCliProvider {
         if (model) {
             argv.push('--model', model);
         }
+        if (reasoningEffort) {
+            argv.push('-c', `model_reasoning_effort=${reasoningEffort}`);
+        }
         // Prefer spawning with cwd, but also set --cd to make Codex aware of root
         if (cwd) {
             argv.push('--cd', cwd);
@@ -95,7 +119,7 @@ export class CodexCliProvider {
             type: 'init',
             timestamp: new Date().toISOString(),
             sessionId: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
-            model: model || 'default',
+            model: resolvedModel.requestedModel || model || 'default',
             provider: this.name,
         };
         yield init;
@@ -108,7 +132,7 @@ export class CodexCliProvider {
             metadata: {
                 provider: this.name,
                 images,
-                effort,
+                effort: reasoningEffort || options?.effort,
                 systemPrompt,
                 appendSystemPrompt,
                 dangerouslyBypassApprovalsAndSandbox: !!options?.dangerouslyBypassApprovalsAndSandbox,
@@ -242,6 +266,7 @@ export class CodexCliProvider {
         // Convenience: collect from execute()
         let content = '';
         const start = Date.now();
+        const resolvedModel = this.resolveModelSpec(options?.model || this.config.defaultModel, options?.effort);
         for await (const msg of this.execute(prompt, options)) {
             if (msg.type === 'assistant' && typeof msg.content === 'string') {
                 content += (content ? '\n' : '') + msg.content;
@@ -250,25 +275,32 @@ export class CodexCliProvider {
         return {
             id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
             provider: this.name,
-            model: options?.model || this.config.defaultModel || 'default',
+            model: resolvedModel.requestedModel || resolvedModel.cliModel || 'default',
             content,
             usage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
             duration: Date.now() - start,
         };
     }
     async detectAvailableModels() {
-        // Current public CLI exposes `--model gpt-5`; effort levels are chosen in-CLI.
+        const capabilities = ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'];
+        const makeModel = (id, displayName) => ({
+            id,
+            name: id,
+            displayName,
+            provider: this.name,
+            contextWindow: 256000,
+            maxOutputTokens: 16384,
+            capabilities,
+        });
         return [
-            {
-                id: 'gpt-5',
-                name: 'gpt-5',
-                displayName: 'gpt‑5',
-                provider: this.name,
-                contextWindow: 256000,
-                maxOutputTokens: 16384,
-                // Capabilities per Codex docs: supports images via --image and advanced reasoning
-                capabilities: ['code', 'analysis', 'tools', 'vision', 'image', 'reasoning'],
-            },
+            makeModel('gpt-5', 'gpt‑5'),
+            makeModel('gpt-5-low', 'gpt‑5 · low reasoning'),
+            makeModel('gpt-5-medium', 'gpt‑5 · medium reasoning'),
+            makeModel('gpt-5-high', 'gpt‑5 · high reasoning'),
+            makeModel('gpt-5-codex', 'gpt‑5 Codex'),
+            makeModel('gpt-5-codex-low', 'gpt‑5 Codex · low reasoning'),
+            makeModel('gpt-5-codex-medium', 'gpt‑5 Codex · medium reasoning'),
+            makeModel('gpt-5-codex-high', 'gpt‑5 Codex · high reasoning'),
         ];
     }
     async validateSetup() {

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

@@ -24,10 +24,12 @@ describe('CodexCliProvider (mocked)', () => {
                     setTimeout(() => proc.emit('exit', 0, null), 20);
                     return proc;
                 },
+                exec: vi.fn(),
+                execFile: vi.fn(),
             };
         });
         const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
-        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000 });
+        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000, codexBinPath: 'codex' });
         const messages = [];
         const iter = provider.execute('What is this project about?', {
             workingDirectory: process.cwd(),
@@ -54,6 +56,47 @@ describe('CodexCliProvider (mocked)', () => {
         const modelIdx = captured[1].indexOf('--model');
         expect(modelIdx).toBeGreaterThan(-1);
         expect(captured[1][modelIdx + 1]).toBe('gpt-5');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=low');
+    });
+    it('maps reasoning level encoded in model name to CLI flags', 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('Reasoned\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
+        const messages = [];
+        const iter = provider.execute('Solve with depth', {
+            workingDirectory: process.cwd(),
+            model: 'gpt-5-codex-high',
+        });
+        for await (const m of iter)
+            messages.push(m);
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        const modelIdx = captured[1].indexOf('--model');
+        expect(modelIdx).toBeGreaterThan(-1);
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5-codex');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=high');
     });
     it('prepends system prompts and toggles sandbox bypass flag', async () => {
         vi.resetModules();
@@ -71,10 +114,12 @@ describe('CodexCliProvider (mocked)', () => {
                     setTimeout(() => proc.emit('exit', 0, null), 10);
                     return proc;
                 },
+                exec: vi.fn(),
+                execFile: vi.fn(),
             };
         });
         const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
-        const provider = new CodexCliProvider();
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
         const iter = provider.execute('Implement feature', {
             workingDirectory: '/tmp/project',
             systemPrompt: 'Base system prompt',

package/dist/runtime/api/agent/routing-policy.d.ts

@@ -6,7 +6,8 @@ import { z } from 'zod';
 /**
  * Operation types that support AI routing
  */
-export type RoutableOperation = 'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge';
+declare const ROUTABLE_OPERATIONS: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
+export type RoutableOperation = (typeof ROUTABLE_OPERATIONS)[number];
 /**
  * Generation options for AI execution
  */
@@ -69,7 +70,7 @@ export type OperationConfig = z.infer<typeof OperationConfigSchema>;
  */
 export declare const RoutingPolicySchema: z.ZodObject<{
     defaultProvider: z.ZodString;
-    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "improve_task", "ai_codereview", "ai_merge"]>, z.ZodObject<{
+    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"]>, z.ZodObject<{
         provider: z.ZodString;
         model: z.ZodOptional<z.ZodString>;
         options: z.ZodOptional<z.ZodObject<{
@@ -107,7 +108,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>>>;
 }, "strip", z.ZodTypeAny, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
         provider: string;
         options?: {
             temperature?: number | undefined;
@@ -119,7 +120,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>> | undefined;
 }, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "improve_task" | "ai_merge" | "ai_codereview", {
         provider: string;
         options?: {
             temperature?: number | undefined;
@@ -131,6 +132,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>> | undefined;
 }>;
 export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
+export declare const ROUTABLE_OPERATION_LIST: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
 /**
  * Resolved provider configuration for execution
  */
@@ -142,47 +144,28 @@ export interface ResolvedProvider {
 }
 /**
  * Routing Policy Manager
- * Manages AI provider routing policies with hot-reload capability
+ * Manages AI provider routing policies stored inside settings.json
  */
 export declare class RoutingPolicyManager {
     private policy;
-    private policyFilePath;
-    private lastModified;
+    private readonly settingsService;
     constructor();
     /**
-     * Get current effective policy with hot-reload
+     * Get current effective policy (lazy loads from settings)
      */
     getPolicy(): Promise<RoutingPolicy>;
     /**
-     * Update routing policy and persist to disk
+     * Update routing policy and persist via settings service
      */
     updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
     /**
      * Resolve provider for a specific operation
      */
+    getEffectivePolicy(): Promise<RoutingPolicy>;
     resolveProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
-    /**
-     * Set default provider
-     */
     setDefaultProvider(provider: string): Promise<void>;
-    /**
-     * Set operation-specific routing
-     */
     setOperationConfig(operation: RoutableOperation, config: OperationConfig): Promise<void>;
-    /**
-     * Validate policy against available providers
-     */
     validatePolicy(policy: RoutingPolicy, availableProviders: Set<string>): string[];
-    /**
-     * Load policy from file if it has changed
-     */
-    private loadPolicyIfChanged;
-    /**
-     * Create example policy file if it doesn't exist
-     */
-    createExamplePolicy(): Promise<void>;
-    /**
-     * Get policy file path for external access
-     */
-    getPolicyFilePath(): string;
+    private buildPolicyFromSettings;
 }
+export {};