vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,915 @@
+export declare const appRouter: import("@trpc/server").TRPCBuiltRouter<{
+    ctx: import("../../types.js").Context;
+    meta: object;
+    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
+    transformer: true;
+}, import("@trpc/server").TRPCDecorateCreateRouterOptions<{
+    detectAllProviders: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, import("../provider-detection.js").DetectionResult>;
+        meta: object;
+    }>;
+    detectProvider: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider: string;
+        };
+        output: import("../provider-detection.js").DetectionResult;
+        meta: object;
+    }>;
+    setProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string;
+            provider: string;
+        };
+        output: {
+            success: boolean;
+            result: import("../provider-detection.js").DetectionResult;
+        };
+        meta: object;
+    }>;
+    clearProviderPath: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    getLocalConfigInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            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;
+            };
+            path: string;
+            exists: boolean;
+            size?: number;
+        };
+        meta: object;
+    }>;
+    clearValidationCache: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    getProviderDiagnostics: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            localConfigPath: string;
+            localConfigExists: boolean;
+            providers: {
+                provider: string;
+                detection: import("../provider-detection.js").DetectionResult;
+                localConfig: {
+                    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;
+                cached: {
+                    available: boolean;
+                    error: string | undefined;
+                    version: string | undefined;
+                    checkedAt: string;
+                    isFresh: boolean;
+                } | null;
+            }[];
+        };
+        meta: object;
+    }>;
+    listProviders: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            name: string;
+            displayName: string;
+            available: boolean;
+            error: string | undefined;
+            capabilities: import("../../agent/ai-providers/types.js").ProviderCapabilities;
+            models: import("../../agent/ai-providers/types.js").ModelInfo[];
+        }[];
+        meta: object;
+    }>;
+    listModels: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            provider?: string | undefined;
+        } | undefined;
+        output: import("../../agent/ai-providers/types.js").ModelInfo[];
+        meta: object;
+    }>;
+    getRoutingPolicy: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: any;
+        meta: object;
+    }>;
+    updateRoutingPolicy: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            policy: {
+                defaultProvider?: string | undefined;
+                operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+                    provider: string;
+                    options?: {
+                        temperature?: number | undefined;
+                        maxTokens?: number | undefined;
+                        tools?: string[] | undefined;
+                    } | undefined;
+                    model?: string | undefined;
+                    fallback?: string[] | undefined;
+                }>> | undefined;
+            };
+        };
+        output: {
+            success: boolean;
+            policy: any;
+        };
+        meta: object;
+    }>;
+    setDefaultProvider: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            provider: string;
+        };
+        output: {
+            success: boolean;
+            provider: string;
+        };
+        meta: object;
+    }>;
+    setOperationConfig: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            operation: "execute_task" | "improve_task" | "ai_merge" | "ai_codereview";
+            config: {
+                provider: string;
+                options?: {
+                    temperature?: number | undefined;
+                    maxTokens?: number | undefined;
+                    tools?: string[] | undefined;
+                } | undefined;
+                model?: string | undefined;
+                fallback?: string[] | undefined;
+            };
+        };
+        output: {
+            success: boolean;
+        };
+        meta: object;
+    }>;
+    validateProviders: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            force?: boolean | undefined;
+        } | undefined;
+        output: {
+            success: boolean;
+            results: {
+                provider: string;
+                available: boolean;
+                error: string | undefined;
+                modelCount: number;
+                capabilities: import("../../agent/ai-providers/types.js").ProviderCapabilities;
+            }[];
+            totalProviders: number;
+            availableProviders: number;
+        };
+        meta: object;
+    }>;
+    getGitStatus: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            current: string;
+            staged: string[];
+            modified: string[];
+            untracked: string[];
+            ahead: number;
+            behind: number;
+        };
+        meta: object;
+    }>;
+    createBranch: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: import("../../vcs/git-service.js").BranchInfo;
+        meta: object;
+    }>;
+    commitChanges: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            message?: string | undefined;
+            files?: string[] | undefined;
+        };
+        output: import("../../vcs/git-service.js").CommitInfo;
+        meta: object;
+    }>;
+    getCommitHistory: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            maxCount?: number | undefined;
+        };
+        output: import("../../vcs/git-service.js").CommitInfo[];
+        meta: object;
+    }>;
+    hasUncommittedChanges: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: boolean;
+        meta: object;
+    }>;
+    getSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    detectQualityChecks: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            checks: {
+                name: string;
+                command: string;
+                args: string[];
+                timeout: number;
+                enabled: boolean;
+            }[];
+            workingDirectory: string;
+        };
+        meta: object;
+    }>;
+    getSetting: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            path: string[];
+        };
+        output: unknown;
+        meta: object;
+    }>;
+    updateSettings: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            path: string[];
+            value?: unknown;
+        }[];
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    resetToDefaults: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: import("../../types/settings.js").VibemanSettings;
+        meta: object;
+    }>;
+    validateSettings: import("@trpc/server").TRPCQueryProcedure<{
+        input: Record<string, unknown>;
+        output: {
+            valid: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    getSettingsInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            path: string;
+            exists: boolean;
+        };
+        meta: object;
+    }>;
+    getEditorPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "vscode" | "cursor" | "vim" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openFileCommand?: string[];
+            openFolderCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    getTerminalPresets: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: Record<string, Partial<{
+            type?: "system" | "iterm2" | "warp" | "custom";
+            command?: string;
+            args?: string[];
+            name?: string;
+            openCommand?: string[];
+        } | undefined>>;
+        meta: object;
+    }>;
+    applyEditorPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    applyTerminalPreset: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            presetName: string;
+        };
+        output: {
+            success: boolean;
+            errors: import("../../types/settings.js").SettingsValidationError[];
+        };
+        meta: object;
+    }>;
+    updateWorkflowOptions: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            config: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
+                autoQualityChecks?: boolean | undefined;
+                requireHumanApproval?: boolean | undefined;
+                stepByStepMode?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
+                aiRoutingOverrides?: {
+                    execute_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    improve_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_merge?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            };
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    startWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            config?: {
+                autoCommit?: boolean | undefined;
+                createPR?: boolean | undefined;
+                autoQualityChecks?: boolean | undefined;
+                requireHumanApproval?: boolean | undefined;
+                stepByStepMode?: boolean | undefined;
+                autoMerge?: boolean | undefined;
+                aiCodeReview?: boolean | undefined;
+                aiRoutingOverrides?: {
+                    execute_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    improve_task?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_merge?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                    ai_codereview?: {
+                        provider?: string | undefined;
+                        model?: string | undefined;
+                    } | undefined;
+                } | undefined;
+            } | undefined;
+        };
+        output: {
+            workflowId: string;
+        };
+        meta: object;
+    }>;
+    continueWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    runValidation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    runMerge: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            provider?: string | undefined;
+            model?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    runCleanup: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    pauseWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    resetWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            force?: boolean | undefined;
+            deleteWorktree?: boolean | undefined;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    approveWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            comments?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    rejectWorkflow: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            feedback: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    onTaskWorkflowEvents: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            taskId?: string | undefined;
+        } | undefined;
+        output: AsyncIterable<{
+            type: "started" | "phase" | "completed" | "failed" | "updated" | "deleted";
+            workflowId: string;
+            phase?: string;
+            workflow?: any;
+            executionId?: string;
+        }, void, any>;
+        meta: object;
+    }>;
+    getWorkflow: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: import("../../types/index.js").VibingExecution | null;
+        meta: object;
+    }>;
+    getWorkflowsByTaskId: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: import("../../types/index.js").VibingExecution[];
+        meta: object;
+    }>;
+    getLatestWorkflowByTaskId: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: import("../../types/index.js").VibingExecution | null;
+        meta: object;
+    }>;
+    aiReviewCode: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            provider?: string | undefined;
+            workflowId?: string | undefined;
+            model?: string | undefined;
+            reviewContext?: string | undefined;
+        };
+        output: {
+            executionId: string;
+            reviewSummary: string;
+            recommendations: string[];
+            qualityScore: number;
+        };
+        meta: object;
+    }>;
+    approveAndContinueReview: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    markCompleted: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    checkWorktreeStatus: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            clean: boolean;
+            uncommittedFiles: string[];
+            worktreePath?: string;
+        };
+        meta: object;
+    }>;
+    rerunImplementation: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            provider?: string | undefined;
+            model?: string | undefined;
+            feedback?: string | undefined;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    skipToNextPhase: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    rerunFromPhase: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            workflowId: string;
+            phase: "completed" | "failed" | "draft" | "awaiting-review" | "approved" | "merged" | "paused" | "implementing" | "validating" | "ai-reviewing" | "merging" | "cleaning";
+        };
+        output: {
+            success: true;
+        };
+        meta: object;
+    }>;
+    listWorktrees: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: (import("../../types/index.js").WorktreeInfo & {
+            isConnectedToTask: boolean;
+        })[];
+        meta: object;
+    }>;
+    syncWorktreeState: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            readonly success: true;
+            readonly message: "Worktree state synchronized";
+        };
+        meta: object;
+    }>;
+    getWorktreeInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    createWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    deleteWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            force?: boolean | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    openInEditor: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    openInTerminal: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    createWorktreePR: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    createPullRequest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            isConnectedToTask: boolean;
+            taskId?: string | undefined;
+            force?: boolean | undefined;
+            worktreePath?: string | undefined;
+            branchName?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    executeTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: {
+            readonly executionId: string;
+        };
+        meta: object;
+    }>;
+    stopTaskExecution: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            executionId: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    getTaskExecutionStatus: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            executionId: string;
+        };
+        output: import("../../types/index.js").AgentExecution | null;
+        meta: object;
+    }>;
+    getTaskExecutionLogs: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            executionId: string;
+        };
+        output: {
+            logs: any[];
+        };
+        meta: object;
+    }>;
+    getTaskExecutions: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: import("../../types/index.js").AgentExecution[];
+        meta: object;
+    }>;
+    getTaskExecutionStats: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            total: number;
+            pending: number;
+            running: number;
+            completed: number;
+            failed: number;
+            cancelled: number;
+            worktrees: {
+                active: number;
+                total: number;
+                enabled: boolean;
+            };
+        };
+        meta: object;
+    }>;
+    improveTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            priority: "high" | "medium" | "low";
+            content: string;
+            taskId: string;
+            executionId?: string | undefined;
+        };
+        output: {
+            type: string;
+            priority: string;
+            content: string;
+            title?: string;
+            executionId: string;
+            selectedModel?: string;
+        };
+        meta: object;
+    }>;
+    onExecutionUpdate: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            executionId: string;
+        };
+        output: AsyncIterable<{
+            executionId: string;
+            status: "pending" | "running" | "completed" | "failed" | "cancelled";
+            logs: string[];
+            error?: string;
+        }, void, any>;
+        meta: object;
+    }>;
+    listTasks: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+            type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+            tags?: string[] | undefined;
+            priority?: "high" | "medium" | "low" | undefined;
+            search?: string | undefined;
+            includeDeleted?: boolean | undefined;
+            onlyDeleted?: boolean | undefined;
+        } | undefined;
+        output: import("../../types/index.js").Task[];
+        meta: object;
+    }>;
+    getTask: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            id: string;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    createTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            title: string;
+            type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+            content: string;
+            status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+            id?: string | undefined;
+            tags?: string[] | undefined;
+            due_date?: string | undefined;
+            assignee?: string[] | undefined;
+            priority?: "high" | "medium" | "low" | undefined;
+            comments?: string[] | undefined;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    updateTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+            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?: "high" | "medium" | "low" | undefined;
+            comments?: string[] | undefined;
+            content?: string | undefined;
+            deleted_at?: string | undefined;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    deleteTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            id: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    moveTask: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            status: "review" | "in-progress" | "backlog" | "done";
+            id: string;
+        };
+        output: import("../../types/index.js").Task;
+        meta: object;
+    }>;
+    getTaskStats: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: any;
+        meta: object;
+    }>;
+    searchTasks: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            query: string;
+            includeDeleted?: boolean | undefined;
+            onlyDeleted?: boolean | undefined;
+        };
+        output: import("../../types/index.js").Task[];
+        meta: object;
+    }>;
+    healthCheck: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: {
+            status: string;
+            timestamp: string;
+            tasksLoaded: number;
+        };
+        meta: object;
+    }>;
+    onTaskUpdate: import("@trpc/server").TRPCSubscriptionProcedure<{
+        input: {
+            taskId?: string | undefined;
+        } | undefined;
+        output: AsyncIterable<{
+            type: "update" | "delete";
+            taskId: string;
+            task?: any;
+        }, void, any>;
+        meta: object;
+    }>;
+    getTaskHistory: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            limit?: number | undefined;
+        };
+        output: {
+            available: boolean;
+            history: import("../../vcs/git-history-service.js").TaskHistoryEntry[];
+            error?: undefined;
+        } | {
+            available: boolean;
+            history: never[];
+            error: string;
+        };
+        meta: object;
+    }>;
+    getTaskVersion: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            commitHash: string;
+        };
+        output: import("../../vcs/git-history-service.js").TaskFileContent;
+        meta: object;
+    }>;
+    getTaskDiff: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+            fromHash: string;
+            toHash: string;
+        };
+        output: import("../../vcs/git-history-service.js").TaskDiffEntry;
+        meta: object;
+    }>;
+}>>;
+export type AppRouter = typeof appRouter;