@planningo/duul 1.0.0

package/build/schemas/execution-partition.js

@@ -0,0 +1,107 @@
+import { z } from 'zod';
+import { ArtifactRefSchema, ReviewerConfigSchema, IterationMetaOutputSchema, TokenUsageOutputSchema } from './common.js';
+export const ExecutionPartitionInputSchema = z.object({
+    approved_plan: z
+        .string()
+        .min(1, 'approved_plan must not be empty')
+        .describe('The previously approved plan to partition into execution units'),
+    workspace_root: z
+        .string()
+        .describe('Absolute path to the workspace root directory'),
+    working_directories: z
+        .array(z.string())
+        .optional()
+        .describe('Subdirectories within workspace_root to restrict scope to'),
+    changed_files: z
+        .array(z.string())
+        .optional()
+        .describe('Files changed in this scope'),
+    entrypoints: z
+        .array(z.string())
+        .optional()
+        .describe('Entry point files'),
+    artifact_refs: z
+        .array(ArtifactRefSchema)
+        .max(30)
+        .optional()
+        .describe('References to important files with reason and priority. Max 30.'),
+    constraints: z
+        .array(z.string())
+        .optional()
+        .describe('Special constraints for partitioning'),
+    max_parallelism: z
+        .number()
+        .min(1)
+        .max(10)
+        .optional()
+        .describe('Maximum number of parallel subtasks. Default 3.'),
+    previous_review_id: z
+        .string()
+        .optional()
+        .describe('Response ID from the plan review. Pass this to give the partitioner ' +
+        'context from the plan review conversation.'),
+    // --- Iteration tracking ---
+    iteration_count: z
+        .number()
+        .min(1)
+        .optional()
+        .describe('Current iteration number (1-based). Caller tracks and increments.'),
+    max_review_iterations: z
+        .number()
+        .min(1)
+        .max(20)
+        .optional()
+        .describe('Override the default iteration limit for this request.'),
+    // --- Reviewer config ---
+    reviewer_config: ReviewerConfigSchema.optional().describe('Per-request reviewer configuration. Overrides env defaults.'),
+});
+const SubtaskScopeSchema = z.object({
+    working_directories: z.array(z.string()).optional().describe('Subdirectories for this subtask'),
+    changed_files: z.array(z.string()).optional().describe('Files this subtask will change'),
+    entrypoints: z.array(z.string()).optional().describe('Entry points for this subtask'),
+    artifact_refs: z.array(ArtifactRefSchema).optional().describe('Relevant files for this subtask'),
+    linked_roots: z.array(z.string()).optional().describe('Read-only external roots this subtask needs'),
+});
+const SubtaskSchema = z.object({
+    id: z.string().describe('Unique subtask identifier'),
+    title: z.string().describe('Short title for the subtask'),
+    goal: z.string().describe('What this subtask accomplishes'),
+    can_run_in_parallel: z.boolean().describe('Whether this subtask can run concurrently with other parallel-eligible subtasks'),
+    depends_on: z.array(z.string()).describe('IDs of subtasks that must complete before this one'),
+    workspace_name_hint: z.string().describe('Suggested workspace name for this subtask'),
+    spawn_strategy: z.enum(['new_workspace', 'reuse_workspace']).describe('Whether to create a new isolated workspace or reuse the existing one. ' +
+        'new_workspace for parallel tasks, reuse_workspace for serial/small changes.'),
+    scope: SubtaskScopeSchema.describe('File scope for this subtask'),
+    handoff_contract: z.array(z.string()).describe('Contracts this subtask must fulfill for downstream subtasks (e.g. "API endpoint /foo uses this schema")'),
+    completion_criteria: z.array(z.string()).describe('Conditions that must be met for this subtask to be complete'),
+    review_focus: z.array(z.string()).describe('What the code reviewer should focus on for this subtask'),
+    risk_level: z.enum(['high', 'medium', 'low']).describe('Risk level of this subtask'),
+});
+const RetryPolicySchema = z.object({
+    max_retries: z.number().describe('Maximum retry attempts per subtask. Default 2.'),
+    on_review_revise: z.literal('retry_subtask').describe('Action when review returns REVISE'),
+    on_tool_exhaustion: z.literal('retry_with_narrower_scope').describe('Action when tool loop is exhausted'),
+    on_conflict: z.literal('serialize_and_retry').describe('Action when two subtasks conflict on the same files'),
+    on_blocker: z.literal('escalate_to_human').describe('Action when a blocking issue cannot be auto-resolved'),
+    on_max_retries_exceeded: z.literal('abort_subtask_and_report').describe('Action when max retries exceeded'),
+});
+export const ExecutionPartitionOutputSchema = z.object({
+    execution_mode: z.enum(['serial', 'parallel', 'hybrid']).describe('Overall execution mode. serial = all subtasks sequential, parallel = all concurrent, hybrid = mixed.'),
+    rationale: z.string().describe('Why this execution mode and partitioning was chosen'),
+    requires_human_checkpoint: z.boolean().describe('Whether a human must confirm before execution begins (shared contracts, security, etc.)'),
+    human_checkpoint_reasons: z
+        .array(z.string())
+        .nullable()
+        .describe('Why a human checkpoint is required'),
+    spawn_strategy: z.enum(['new_workspace', 'reuse_workspace']).describe('Default spawn strategy for subtasks. Individual subtasks can override.'),
+    handoff_artifact_pattern: z.string().describe('File pattern for subtask results, e.g. ".context/subtasks/{subtask_id}.json"'),
+    subtask_result_schema_version: z.literal('1.0').describe('Version of the subtask result schema'),
+    subtasks: z.array(SubtaskSchema).describe('Ordered list of subtasks'),
+    global_checkpoints: z.array(z.string()).describe('Points where all prior subtasks must complete before continuing'),
+    merge_order: z.array(z.string()).describe('Order in which subtask branches should be merged'),
+    retry_policy: RetryPolicySchema.describe('Policy for handling failures during execution'),
+});
+export const ExecutionPartitionMcpOutputSchema = ExecutionPartitionOutputSchema
+    .extend({ review_id: z.string().describe('Response ID for context continuity') })
+    .merge(IterationMetaOutputSchema)
+    .merge(TokenUsageOutputSchema);

package/build/schemas/plan-review.d.ts

@@ -0,0 +1,523 @@
+import { z } from 'zod';
+export declare const ProjectContextSchema: z.ZodObject<{
+    file_tree: z.ZodOptional<z.ZodString>;
+    changed_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    package_versions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    relevant_code: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        file_path: z.ZodString;
+        code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        file_path: string;
+    }, {
+        code: string;
+        file_path: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    file_tree?: string | undefined;
+    changed_files?: string[] | undefined;
+    package_versions?: Record<string, string> | undefined;
+    relevant_code?: {
+        code: string;
+        file_path: string;
+    }[] | undefined;
+}, {
+    file_tree?: string | undefined;
+    changed_files?: string[] | undefined;
+    package_versions?: Record<string, string> | undefined;
+    relevant_code?: {
+        code: string;
+        file_path: string;
+    }[] | undefined;
+}>;
+export declare const PlanReviewInputSchema: z.ZodObject<{
+    plan: z.ZodString;
+    project_context: z.ZodOptional<z.ZodObject<{
+        file_tree: z.ZodOptional<z.ZodString>;
+        changed_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        package_versions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        relevant_code: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            file_path: z.ZodString;
+            code: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            code: string;
+            file_path: string;
+        }, {
+            code: string;
+            file_path: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        file_tree?: string | undefined;
+        changed_files?: string[] | undefined;
+        package_versions?: Record<string, string> | undefined;
+        relevant_code?: {
+            code: string;
+            file_path: string;
+        }[] | undefined;
+    }, {
+        file_tree?: string | undefined;
+        changed_files?: string[] | undefined;
+        package_versions?: Record<string, string> | undefined;
+        relevant_code?: {
+            code: string;
+            file_path: string;
+        }[] | undefined;
+    }>>;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    notes_to_reviewer: z.ZodOptional<z.ZodString>;
+    user_original_request: z.ZodOptional<z.ZodString>;
+    workspace_root: z.ZodOptional<z.ZodString>;
+    project_root: z.ZodOptional<z.ZodString>;
+    working_directories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    linked_roots: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    changed_files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    entrypoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    artifact_refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodString;
+        priority: z.ZodEnum<["high", "medium", "low"]>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        reason: string;
+        priority: "high" | "medium" | "low";
+    }, {
+        path: string;
+        reason: string;
+        priority: "high" | "medium" | "low";
+    }>, "many">>;
+    tracked_only: z.ZodOptional<z.ZodBoolean>;
+    git_head_sha: z.ZodOptional<z.ZodString>;
+    previous_git_head_sha: z.ZodOptional<z.ZodString>;
+    workspace_name: z.ZodOptional<z.ZodString>;
+    setup_script_present: z.ZodOptional<z.ZodBoolean>;
+    run_script_present: z.ZodOptional<z.ZodBoolean>;
+    environment_files_expected: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    git_diff: z.ZodOptional<z.ZodString>;
+    git_diff_base: z.ZodOptional<z.ZodString>;
+    previous_review_id: z.ZodOptional<z.ZodString>;
+    iteration_count: z.ZodOptional<z.ZodNumber>;
+    max_review_iterations: z.ZodOptional<z.ZodNumber>;
+    reviewer_config: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodEnum<["openai", "anthropic", "google", "openrouter", "compatible"]>>;
+        model: z.ZodOptional<z.ZodString>;
+        base_url: z.ZodOptional<z.ZodString>;
+        api_key: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider?: "openai" | "anthropic" | "google" | "openrouter" | "compatible" | undefined;
+        model?: string | undefined;
+        base_url?: string | undefined;
+        api_key?: string | undefined;
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+    }, {
+        provider?: "openai" | "anthropic" | "google" | "openrouter" | "compatible" | undefined;
+        model?: string | undefined;
+        base_url?: string | undefined;
+        api_key?: string | undefined;
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    plan: string;
+    iteration_count?: number | undefined;
+    changed_files?: string[] | undefined;
+    project_context?: {
+        file_tree?: string | undefined;
+        changed_files?: string[] | undefined;
+        package_versions?: Record<string, string> | undefined;
+        relevant_code?: {
+            code: string;
+            file_path: string;
+        }[] | undefined;
+    } | undefined;
+    constraints?: string[] | undefined;
+    notes_to_reviewer?: string | undefined;
+    user_original_request?: string | undefined;
+    workspace_root?: string | undefined;
+    project_root?: string | undefined;
+    working_directories?: string[] | undefined;
+    linked_roots?: string[] | undefined;
+    entrypoints?: string[] | undefined;
+    artifact_refs?: {
+        path: string;
+        reason: string;
+        priority: "high" | "medium" | "low";
+    }[] | undefined;
+    tracked_only?: boolean | undefined;
+    git_head_sha?: string | undefined;
+    previous_git_head_sha?: string | undefined;
+    workspace_name?: string | undefined;
+    setup_script_present?: boolean | undefined;
+    run_script_present?: boolean | undefined;
+    environment_files_expected?: string[] | undefined;
+    git_diff?: string | undefined;
+    git_diff_base?: string | undefined;
+    previous_review_id?: string | undefined;
+    max_review_iterations?: number | undefined;
+    reviewer_config?: {
+        provider?: "openai" | "anthropic" | "google" | "openrouter" | "compatible" | undefined;
+        model?: string | undefined;
+        base_url?: string | undefined;
+        api_key?: string | undefined;
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+    } | undefined;
+}, {
+    plan: string;
+    iteration_count?: number | undefined;
+    changed_files?: string[] | undefined;
+    project_context?: {
+        file_tree?: string | undefined;
+        changed_files?: string[] | undefined;
+        package_versions?: Record<string, string> | undefined;
+        relevant_code?: {
+            code: string;
+            file_path: string;
+        }[] | undefined;
+    } | undefined;
+    constraints?: string[] | undefined;
+    notes_to_reviewer?: string | undefined;
+    user_original_request?: string | undefined;
+    workspace_root?: string | undefined;
+    project_root?: string | undefined;
+    working_directories?: string[] | undefined;
+    linked_roots?: string[] | undefined;
+    entrypoints?: string[] | undefined;
+    artifact_refs?: {
+        path: string;
+        reason: string;
+        priority: "high" | "medium" | "low";
+    }[] | undefined;
+    tracked_only?: boolean | undefined;
+    git_head_sha?: string | undefined;
+    previous_git_head_sha?: string | undefined;
+    workspace_name?: string | undefined;
+    setup_script_present?: boolean | undefined;
+    run_script_present?: boolean | undefined;
+    environment_files_expected?: string[] | undefined;
+    git_diff?: string | undefined;
+    git_diff_base?: string | undefined;
+    previous_review_id?: string | undefined;
+    max_review_iterations?: number | undefined;
+    reviewer_config?: {
+        provider?: "openai" | "anthropic" | "google" | "openrouter" | "compatible" | undefined;
+        model?: string | undefined;
+        base_url?: string | undefined;
+        api_key?: string | undefined;
+        temperature?: number | undefined;
+        top_p?: number | undefined;
+    } | undefined;
+}>;
+export declare const PlanReviewOutputSchema: z.ZodObject<{
+    verdict: z.ZodEnum<["APPROVE", "REVISE"]>;
+    review_status: z.ZodEnum<["completed", "incomplete"]>;
+    confidence: z.ZodNumber;
+    requires_human_review: z.ZodBoolean;
+    architectural_analysis: z.ZodString;
+    blocking_issues: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        suggestion: string;
+    }, {
+        description: string;
+        suggestion: string;
+    }>, "many">;
+    merge_blockers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        suggestion: string;
+    }, {
+        description: string;
+        suggestion: string;
+    }>, "many">>;
+    non_blocking_suggestions: z.ZodArray<z.ZodString, "many">;
+    edge_cases: z.ZodArray<z.ZodString, "many">;
+    checklist_for_implementation: z.ZodArray<z.ZodString, "many">;
+    follow_up_todos: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    missing_context: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    evidence_files: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    used_tools: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    tool_exhaustion_reason: z.ZodNullable<z.ZodEnum<["budget", "repeat", "round_limit"]>>;
+    parallelization_hint: z.ZodNullable<z.ZodEnum<["serial", "parallel", "hybrid"]>>;
+    coordination_risks: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    recommended_subtask_boundaries: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    user_original_request_echo: z.ZodNullable<z.ZodString>;
+    symptom_impact: z.ZodNullable<z.ZodObject<{
+        before: z.ZodString;
+        after: z.ZodString;
+        causal_chain: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        before: string;
+        after: string;
+        causal_chain: string;
+    }, {
+        before: string;
+        after: string;
+        causal_chain: string;
+    }>>;
+    symptom_match_notes: z.ZodNullable<z.ZodString>;
+    gates_tripped: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    verdict: "APPROVE" | "REVISE";
+    review_status: "completed" | "incomplete";
+    confidence: number;
+    requires_human_review: boolean;
+    architectural_analysis: string;
+    blocking_issues: {
+        description: string;
+        suggestion: string;
+    }[];
+    merge_blockers: {
+        description: string;
+        suggestion: string;
+    }[] | null;
+    non_blocking_suggestions: string[];
+    edge_cases: string[];
+    checklist_for_implementation: string[];
+    follow_up_todos: string[] | null;
+    missing_context: string[] | null;
+    evidence_files: string[] | null;
+    used_tools: string[] | null;
+    tool_exhaustion_reason: "budget" | "repeat" | "round_limit" | null;
+    parallelization_hint: "serial" | "parallel" | "hybrid" | null;
+    coordination_risks: string[] | null;
+    recommended_subtask_boundaries: string[] | null;
+    user_original_request_echo: string | null;
+    symptom_impact: {
+        before: string;
+        after: string;
+        causal_chain: string;
+    } | null;
+    symptom_match_notes: string | null;
+    gates_tripped: string[] | null;
+}, {
+    verdict: "APPROVE" | "REVISE";
+    review_status: "completed" | "incomplete";
+    confidence: number;
+    requires_human_review: boolean;
+    architectural_analysis: string;
+    blocking_issues: {
+        description: string;
+        suggestion: string;
+    }[];
+    merge_blockers: {
+        description: string;
+        suggestion: string;
+    }[] | null;
+    non_blocking_suggestions: string[];
+    edge_cases: string[];
+    checklist_for_implementation: string[];
+    follow_up_todos: string[] | null;
+    missing_context: string[] | null;
+    evidence_files: string[] | null;
+    used_tools: string[] | null;
+    tool_exhaustion_reason: "budget" | "repeat" | "round_limit" | null;
+    parallelization_hint: "serial" | "parallel" | "hybrid" | null;
+    coordination_risks: string[] | null;
+    recommended_subtask_boundaries: string[] | null;
+    user_original_request_echo: string | null;
+    symptom_impact: {
+        before: string;
+        after: string;
+        causal_chain: string;
+    } | null;
+    symptom_match_notes: string | null;
+    gates_tripped: string[] | null;
+}>;
+export declare const PlanReviewMcpOutputSchema: z.ZodObject<{
+    verdict: z.ZodEnum<["APPROVE", "REVISE"]>;
+    review_status: z.ZodEnum<["completed", "incomplete"]>;
+    confidence: z.ZodNumber;
+    requires_human_review: z.ZodBoolean;
+    architectural_analysis: z.ZodString;
+    blocking_issues: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        suggestion: string;
+    }, {
+        description: string;
+        suggestion: string;
+    }>, "many">;
+    merge_blockers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        suggestion: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        suggestion: string;
+    }, {
+        description: string;
+        suggestion: string;
+    }>, "many">>;
+    non_blocking_suggestions: z.ZodArray<z.ZodString, "many">;
+    edge_cases: z.ZodArray<z.ZodString, "many">;
+    checklist_for_implementation: z.ZodArray<z.ZodString, "many">;
+    follow_up_todos: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    missing_context: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    evidence_files: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    used_tools: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    tool_exhaustion_reason: z.ZodNullable<z.ZodEnum<["budget", "repeat", "round_limit"]>>;
+    parallelization_hint: z.ZodNullable<z.ZodEnum<["serial", "parallel", "hybrid"]>>;
+    coordination_risks: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    recommended_subtask_boundaries: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+    user_original_request_echo: z.ZodNullable<z.ZodString>;
+    symptom_impact: z.ZodNullable<z.ZodObject<{
+        before: z.ZodString;
+        after: z.ZodString;
+        causal_chain: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        before: string;
+        after: string;
+        causal_chain: string;
+    }, {
+        before: string;
+        after: string;
+        causal_chain: string;
+    }>>;
+    symptom_match_notes: z.ZodNullable<z.ZodString>;
+    gates_tripped: z.ZodNullable<z.ZodArray<z.ZodString, "many">>;
+} & {
+    review_id: z.ZodString;
+} & {
+    iteration_count: z.ZodNumber;
+    iteration_limit: z.ZodNumber;
+    iteration_limit_reached: z.ZodBoolean;
+} & {
+    token_usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+        total_tokens: z.ZodNumber;
+        api_calls: z.ZodNumber;
+        provider: z.ZodString;
+        model: z.ZodString;
+        estimated_cost_usd: z.ZodNullable<z.ZodNumber>;
+        cached_input_tokens: z.ZodOptional<z.ZodNumber>;
+        cache_creation_input_tokens: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        model: string;
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        api_calls: number;
+        estimated_cost_usd: number | null;
+        cached_input_tokens?: number | undefined;
+        cache_creation_input_tokens?: number | undefined;
+    }, {
+        provider: string;
+        model: string;
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        api_calls: number;
+        estimated_cost_usd: number | null;
+        cached_input_tokens?: number | undefined;
+        cache_creation_input_tokens?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    iteration_count: number;
+    iteration_limit: number;
+    iteration_limit_reached: boolean;
+    token_usage: {
+        provider: string;
+        model: string;
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        api_calls: number;
+        estimated_cost_usd: number | null;
+        cached_input_tokens?: number | undefined;
+        cache_creation_input_tokens?: number | undefined;
+    };
+    verdict: "APPROVE" | "REVISE";
+    review_status: "completed" | "incomplete";
+    confidence: number;
+    requires_human_review: boolean;
+    architectural_analysis: string;
+    blocking_issues: {
+        description: string;
+        suggestion: string;
+    }[];
+    merge_blockers: {
+        description: string;
+        suggestion: string;
+    }[] | null;
+    non_blocking_suggestions: string[];
+    edge_cases: string[];
+    checklist_for_implementation: string[];
+    follow_up_todos: string[] | null;
+    missing_context: string[] | null;
+    evidence_files: string[] | null;
+    used_tools: string[] | null;
+    tool_exhaustion_reason: "budget" | "repeat" | "round_limit" | null;
+    parallelization_hint: "serial" | "parallel" | "hybrid" | null;
+    coordination_risks: string[] | null;
+    recommended_subtask_boundaries: string[] | null;
+    user_original_request_echo: string | null;
+    symptom_impact: {
+        before: string;
+        after: string;
+        causal_chain: string;
+    } | null;
+    symptom_match_notes: string | null;
+    gates_tripped: string[] | null;
+    review_id: string;
+}, {
+    iteration_count: number;
+    iteration_limit: number;
+    iteration_limit_reached: boolean;
+    token_usage: {
+        provider: string;
+        model: string;
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        api_calls: number;
+        estimated_cost_usd: number | null;
+        cached_input_tokens?: number | undefined;
+        cache_creation_input_tokens?: number | undefined;
+    };
+    verdict: "APPROVE" | "REVISE";
+    review_status: "completed" | "incomplete";
+    confidence: number;
+    requires_human_review: boolean;
+    architectural_analysis: string;
+    blocking_issues: {
+        description: string;
+        suggestion: string;
+    }[];
+    merge_blockers: {
+        description: string;
+        suggestion: string;
+    }[] | null;
+    non_blocking_suggestions: string[];
+    edge_cases: string[];
+    checklist_for_implementation: string[];
+    follow_up_todos: string[] | null;
+    missing_context: string[] | null;
+    evidence_files: string[] | null;
+    used_tools: string[] | null;
+    tool_exhaustion_reason: "budget" | "repeat" | "round_limit" | null;
+    parallelization_hint: "serial" | "parallel" | "hybrid" | null;
+    coordination_risks: string[] | null;
+    recommended_subtask_boundaries: string[] | null;
+    user_original_request_echo: string | null;
+    symptom_impact: {
+        before: string;
+        after: string;
+        causal_chain: string;
+    } | null;
+    symptom_match_notes: string | null;
+    gates_tripped: string[] | null;
+    review_id: string;
+}>;
+export type PlanReviewInput = z.infer<typeof PlanReviewInputSchema>;
+export type PlanReviewOutput = z.infer<typeof PlanReviewOutputSchema>;
+export type PlanReviewMcpOutput = z.infer<typeof PlanReviewMcpOutputSchema>;