vibeman 0.0.1 → 0.0.3

package/dist/runtime/api/api/routers/workflows.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { on, EventEmitter } from 'events';
 import { publicProcedure } from '../trpc.js';
 import { TRPCError } from '@trpc/server';
-export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+export function buildWorkflowRoutes({ vibingOrchestrator }) {
     const OperationOverrideSchema = z.object({
         provider: z.string().optional(),
         model: z.string().optional(),
@@ -10,9 +10,10 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
     const WorkflowAIRoutingOverrides = z
         .object({
         execute_task: OperationOverrideSchema.optional(),
-        improve_task: OperationOverrideSchema.optional(),
+        quality_checks: OperationOverrideSchema.optional(),
         ai_codereview: OperationOverrideSchema.optional(),
         ai_merge: OperationOverrideSchema.optional(),
+        improve_task: OperationOverrideSchema.optional(),
     })
         .partial();
     const WorkflowConfig = z.object({
@@ -30,14 +31,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         updateWorkflowOptions: publicProcedure
             .input(z.object({ workflowId: z.string(), config: WorkflowConfig }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.updateWorkflowOptions(input.workflowId, input.config);
             return { success: true };
         }),
         startWorkflow: publicProcedure
             .input(z.object({ taskId: z.string(), config: WorkflowConfigOpt }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const workflowId = await orchestrator.startWorkflow(input.taskId, input.config || {});
             return { workflowId };
         }),
@@ -45,7 +46,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
             try {
-                const orchestrator = await requireOrchestrator();
+                const orchestrator = vibingOrchestrator;
                 await orchestrator.continueWorkflow(input.workflowId);
                 return { success: true };
             }
@@ -58,7 +59,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         runValidation: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runValidation(input.workflowId);
             return { success: true };
         }),
@@ -69,7 +70,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runMerge(input.workflowId, {
                 provider: input.provider,
                 model: input.model,
@@ -79,14 +80,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         runCleanup: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.runCleanup(input.workflowId);
             return { success: true };
         }),
         pauseWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.pauseWorkflow(input.workflowId);
             return { success: true };
         }),
@@ -97,7 +98,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             force: z.boolean().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.resetWorkflow(input.workflowId, {
                 deleteWorktree: input.deleteWorktree,
                 force: input.force,
@@ -107,14 +108,14 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         approveWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string(), comments: z.string().optional() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.approveWorkflow(input.workflowId);
             return { success: true };
         }),
         rejectWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string(), feedback: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rejectWorkflow(input.workflowId, input.feedback);
             return { success: true };
         }),
@@ -122,7 +123,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             .input(z.object({ taskId: z.string().optional() }).optional())
             .subscription(async function* (opts) {
             const input = opts.input;
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             const proxy = new EventEmitter();
             const handleStarted = (workflow) => {
                 if (!input?.taskId || workflow.taskId === input.taskId)
@@ -208,22 +209,22 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         getWorkflow: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getWorkflow(input.workflowId);
         }),
         getWorkflowsByTaskId: publicProcedure
             .input(z.object({ taskId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getTaskWorkflows(input.taskId);
         }),
         getLatestWorkflowByTaskId: publicProcedure
             .input(z.object({ taskId: z.string() }))
             .query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return orchestrator.getLatestWorkflowByTask(input.taskId);
         }),
-        reviewCode: publicProcedure
+        aiReviewCode: publicProcedure
             .input(z.object({
             taskId: z.string(),
             workflowId: z.string().optional(),
@@ -232,31 +233,33 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
-            return await orchestrator.reviewCode(input.taskId, input.reviewContext, {
+            const orchestrator = vibingOrchestrator;
+            const overrides = input.provider || input.model
+                ? { provider: input.provider, model: input.model }
+                : undefined;
+            return await orchestrator.aiReviewCode(input.taskId, input.reviewContext, {
                 workflowId: input.workflowId,
-                provider: input.provider,
-                model: input.model,
+                overrides,
             });
         }),
         approveAndContinueReview: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.approveAndContinueReview(input.workflowId);
             return { success: true };
         }),
         markCompleted: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.markWorkflowCompleted(input.workflowId);
             return { success: true };
         }),
         checkWorktreeStatus: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.checkWorktreeStatus(input.workflowId);
         }),
         rerunImplementation: publicProcedure
@@ -267,7 +270,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             model: z.string().optional(),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rerunImplementation(input.workflowId, input.feedback, {
                 provider: input.provider,
                 model: input.model,
@@ -277,7 +280,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
         skipToNextPhase: publicProcedure
             .input(z.object({ workflowId: z.string() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.skipToNextPhase(input.workflowId);
             return { success: true };
         }),
@@ -300,7 +303,7 @@ export function buildWorkflowRoutes({ requireOrchestrator, requireOrchestratorSy
             ]),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.rerunPhase(input.workflowId, input.phase);
             return { success: true };
         }),

package/dist/runtime/api/api/routers/worktrees.d.ts

@@ -1,9 +1,8 @@
 import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
 type Deps = {
-    requireOrchestrator: () => Promise<VibingOrchestrator>;
-    requireOrchestratorSync: () => VibingOrchestrator;
+    vibingOrchestrator: VibingOrchestrator;
 };
-export declare function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }: Deps): {
+export declare function buildWorktreeRoutes({ vibingOrchestrator }: Deps): {
     readonly listWorktrees: import("@trpc/server").TRPCQueryProcedure<{
         input: void;
         output: (import("../../types/index.js").WorktreeInfo & {
@@ -88,9 +87,9 @@ export declare function buildWorktreeRoutes({ requireOrchestrator, requireOrches
     readonly cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
         input: {
             isConnectedToTask: boolean;
-            worktreePath?: string | undefined;
-            force?: boolean | undefined;
             taskId?: string | undefined;
+            force?: boolean | undefined;
+            worktreePath?: string | undefined;
             branchName?: string | undefined;
         };
         output: {

package/dist/runtime/api/api/routers/worktrees.js

@@ -2,19 +2,19 @@ import { z } from 'zod';
 import { publicProcedure } from '../trpc.js';
 import { TaskIdSchema, WorktreePathSchema, withErrors } from '../router-helpers.js';
 import { log } from '../../lib/logger.js';
-export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSync }) {
+export function buildWorktreeRoutes({ vibingOrchestrator }) {
     return {
         listWorktrees: publicProcedure.query(withErrors('list worktrees', 'router:listWorktrees', async () => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.listWorktrees();
         })),
         syncWorktreeState: publicProcedure.mutation(withErrors('sync worktree state', 'router:syncWorktreeState', async () => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.syncWorktreeState();
             return { success: true, message: 'Worktree state synchronized' };
         })),
         getWorktreeInfo: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const worktree = orchestrator.getWorktreeInfo(input.taskId);
             if (!worktree)
                 return null;
@@ -22,7 +22,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             return serializableWorktree;
         }),
         createWorktree: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             const worktree = await orchestrator.createWorktree(input.taskId);
             const { git, ...serializableWorktree } = worktree;
             return serializableWorktree;
@@ -30,7 +30,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
         deleteWorktree: publicProcedure
             .input(z.object({ taskId: z.string(), force: z.coerce.boolean().optional() }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.deleteWorktree(input.taskId, input.force || false);
             if (orchestrator) {
                 await orchestrator.removeWorkflowsByTask(input.taskId);
@@ -38,13 +38,13 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             return { success: true };
         }),
         openInEditor: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in editor', 'router:openInEditor', async ({ input }) => {
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.openInEditor(input.worktreePath);
             // Ensure we return a clean, serializable object
             return { success: true };
         })),
         openInTerminal: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in terminal', 'router:openInTerminal', async ({ input }) => {
-            const orchestrator = requireOrchestratorSync();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.openInTerminal(input.worktreePath);
             // Ensure we return a clean, serializable object
             return { success: true };
@@ -53,14 +53,14 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
         createWorktreePR: publicProcedure
             .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             log.warn('Deprecated route used: createWorktreePR; prefer createPullRequest', { taskId: input.taskId }, 'router:createWorktreePR');
             return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
         }),
         createPullRequest: publicProcedure
             .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
             .mutation(withErrors('create pull request', 'router:createPullRequest', async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
         })),
         cleanupWorktree: publicProcedure
@@ -72,7 +72,7 @@ export function buildWorktreeRoutes({ requireOrchestrator, requireOrchestratorSy
             force: z.coerce.boolean().optional().default(false),
         }))
             .mutation(async ({ input }) => {
-            const orchestrator = await requireOrchestrator();
+            const orchestrator = vibingOrchestrator;
             await orchestrator.cleanupWorktree(input);
             return { success: true };
         }),

package/dist/runtime/api/api/trpc.d.ts

@@ -31,26 +31,26 @@ export declare const TaskCreateSchema: z.ZodObject<{
     comments: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     content: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-    status: "backlog" | "in-progress" | "review" | "done";
-    priority: "low" | "medium" | "high";
+    status: "review" | "in-progress" | "backlog" | "done";
     title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     tags: string[];
     assignee: string[];
+    priority: "low" | "medium" | "high";
     comments: string[];
     content: string;
     id?: string | undefined;
     due_date?: string | undefined;
 }, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
     content: string;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     id?: string | undefined;
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
 }>;
 export declare const TaskUpdateSchema: z.ZodObject<{
@@ -68,25 +68,25 @@ export declare const TaskUpdateSchema: z.ZodObject<{
     deleted_at: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
     content?: string | undefined;
     deleted_at?: string | undefined;
 }, {
     id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
     tags?: string[] | undefined;
     due_date?: string | undefined;
     assignee?: string[] | undefined;
+    priority?: "low" | "medium" | "high" | undefined;
     comments?: string[] | undefined;
     content?: string | undefined;
     deleted_at?: string | undefined;
@@ -100,19 +100,19 @@ export declare const TaskFilterSchema: z.ZodObject<{
     includeDeleted: z.ZodOptional<z.ZodBoolean>;
     onlyDeleted: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    tags?: string[] | undefined;
     priority?: "low" | "medium" | "high" | undefined;
     search?: string | undefined;
-    tags?: string[] | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;
 }, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
     type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
+    tags?: string[] | undefined;
     priority?: "low" | "medium" | "high" | undefined;
     search?: string | undefined;
-    tags?: string[] | undefined;
     includeDeleted?: boolean | undefined;
     onlyDeleted?: boolean | undefined;
 }>;

package/dist/runtime/api/index.js

@@ -100,16 +100,8 @@ try {
     if (isMain) {
         const host = process.env.HOST || 'localhost';
         const resolveApiPort = async () => {
-            // Highest precedence: explicit API port
-            const explicit = getNumberEnv('VIBEMAN_API_PORT', NaN);
-            if (Number.isFinite(explicit) && explicit > 0)
-                return explicit;
-            // If PORT (web) is set, use web+1
-            const webPort = getNumberEnv('PORT', 0);
-            if (webPort > 0)
-                return webPort + 1;
-            // Default dev behavior: assume web on 3000, so API on 3001
-            return 3001;
+            const port = getNumberEnv('PORT', 3000);
+            return port + 1;
         };
         (async () => {
             const port = await resolveApiPort();

package/dist/runtime/api/lib/local-config.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Local Configuration Manager
+ * Handles machine-specific configuration that should not be committed to git
+ */
+import { EventEmitter } from 'events';
+import { z } from 'zod';
+declare const LocalConfigSchema: z.ZodObject<{
+    providers: z.ZodOptional<z.ZodObject<{
+        'claude-code': z.ZodOptional<z.ZodObject<{
+            binPath: z.ZodOptional<z.ZodString>;
+            detectedPath: z.ZodOptional<z.ZodString>;
+            lastDetected: z.ZodOptional<z.ZodString>;
+            detectionMethod: z.ZodOptional<z.ZodEnum<["explicit", "PATH", "common-location"]>>;
+        }, "strip", z.ZodTypeAny, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }>>;
+        codex: z.ZodOptional<z.ZodObject<{
+            binPath: z.ZodOptional<z.ZodString>;
+            detectedPath: z.ZodOptional<z.ZodString>;
+            lastDetected: z.ZodOptional<z.ZodString>;
+            detectionMethod: z.ZodOptional<z.ZodEnum<["explicit", "PATH", "common-location"]>>;
+        }, "strip", z.ZodTypeAny, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }, {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    }, {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    }>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        lastProviderValidation: z.ZodOptional<z.ZodString>;
+        validationResults: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            available: z.ZodBoolean;
+            error: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            checkedAt: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    }, {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    providers?: {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    } | undefined;
+    cache?: {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    } | undefined;
+}, {
+    providers?: {
+        'claude-code'?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+        codex?: {
+            binPath?: string | undefined;
+            detectedPath?: string | undefined;
+            lastDetected?: string | undefined;
+            detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+        } | undefined;
+    } | undefined;
+    cache?: {
+        lastProviderValidation?: string | undefined;
+        validationResults?: Record<string, {
+            available: boolean;
+            checkedAt: string;
+            error?: string | undefined;
+            version?: string | undefined;
+        }> | undefined;
+    } | undefined;
+}>;
+export type LocalConfig = z.infer<typeof LocalConfigSchema>;
+export interface LocalConfigServiceConfig {
+    configDir?: string;
+    configFileName?: string;
+}
+/**
+ * Local Configuration Service
+ * Manages machine-specific configuration stored in local-only directory
+ */
+export declare class LocalConfigService extends EventEmitter {
+    private config;
+    private configPath;
+    private initialized;
+    constructor(options?: LocalConfigServiceConfig);
+    /**
+     * Initialize the local config service
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get the full local configuration
+     */
+    getConfig(): LocalConfig;
+    /**
+     * Get provider-specific configuration
+     */
+    getProviderConfig(provider: 'claude-code' | 'codex'): {
+        binPath?: string | undefined;
+        detectedPath?: string | undefined;
+        lastDetected?: string | undefined;
+        detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+    } | {
+        binPath?: string | undefined;
+        detectedPath?: string | undefined;
+        lastDetected?: string | undefined;
+        detectionMethod?: "explicit" | "PATH" | "common-location" | undefined;
+    } | undefined;
+    /**
+     * Set provider binary path and detection info
+     */
+    setProviderPath(provider: 'claude-code' | 'codex', binPath: string, detectionMethod?: 'explicit' | 'PATH' | 'common-location'): Promise<void>;
+    updateDetectedProvider(provider: 'claude-code' | 'codex', detectedPath: string, detectionMethod?: 'PATH' | 'common-location'): Promise<void>;
+    /**
+     * Clear provider configuration
+     */
+    clearProviderPath(provider: 'claude-code' | 'codex'): Promise<void>;
+    /**
+     * Cache provider validation results
+     */
+    cacheValidationResult(provider: string, result: {
+        available: boolean;
+        error?: string;
+        version?: string;
+    }): Promise<void>;
+    /**
+     * Get cached validation result
+     */
+    getCachedValidationResult(provider: string): {
+        available: boolean;
+        error?: string;
+        version?: string;
+        checkedAt: string;
+    } | undefined;
+    /**
+     * Check if cached validation is still fresh (within last 5 minutes)
+     */
+    isCachedValidationFresh(provider: string): boolean;
+    /**
+     * Clear all cached validation results
+     */
+    clearValidationCache(): Promise<void>;
+    /**
+     * Get configuration file information
+     */
+    getConfigInfo(): Promise<{
+        path: string;
+        exists: boolean;
+        size?: number;
+    }>;
+    /**
+     * Export configuration for debugging/backup
+     */
+    exportConfig(): Promise<string>;
+    /**
+     * Import configuration from JSON string
+     */
+    importConfig(configJson: string): Promise<void>;
+    private ensureConfigDirectory;
+    private loadConfig;
+    private saveConfig;
+    private fileExists;
+    private mergeWithDefaults;
+}
+export declare function getLocalConfigService(config?: LocalConfigServiceConfig): LocalConfigService;
+export {};