@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/tools/vibe_pm/types/schemas.d.ts

@@ -0,0 +1,4003 @@
+export declare const briefingInputSchema: import("zod").ZodObject<{
+    project_brief: import("zod").ZodString;
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<["mvp_fast", "balanced", "quality_first"]>>;
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    mode: "mvp_fast" | "balanced" | "quality_first";
+    project_brief: string;
+    project_id?: string | undefined;
+}, {
+    project_brief: string;
+    mode?: "mvp_fast" | "balanced" | "quality_first" | undefined;
+    project_id?: string | undefined;
+}>;
+export declare const briefingOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    pm_summary: import("zod").ZodObject<{
+        goal: import("zod").ZodString;
+        target_user: import("zod").ZodString;
+        first_milestone: import("zod").ZodString;
+        top_risk: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        goal: string;
+        target_user: string;
+        first_milestone: string;
+        top_risk: string;
+    }, {
+        goal: string;
+        target_user: string;
+        first_milestone: string;
+        top_risk: string;
+    }>;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.get_decision">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.get_decision";
+        reason: string;
+    }, {
+        tool: "vibe_pm.get_decision";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.get_decision";
+        reason: string;
+    };
+    pm_summary: {
+        goal: string;
+        target_user: string;
+        first_milestone: string;
+        top_risk: string;
+    };
+}, {
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.get_decision";
+        reason: string;
+    };
+    pm_summary: {
+        goal: string;
+        target_user: string;
+        first_milestone: string;
+        top_risk: string;
+    };
+}>;
+export declare const getDecisionInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    max_items: import("zod").ZodDefault<import("zod").ZodNumber>;
+    auto_select: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    max_items: number;
+    auto_select: boolean;
+    project_id?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    max_items?: number | undefined;
+    auto_select?: boolean | undefined;
+}>;
+export declare const getDecisionOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    decision_requests: import("zod").ZodArray<import("zod").ZodObject<{
+        decision_id: import("zod").ZodString;
+        title: import("zod").ZodString;
+        context: import("zod").ZodString;
+        choices: import("zod").ZodArray<import("zod").ZodObject<{
+            key: import("zod").ZodEnum<["A", "B", "C", "U"]>;
+            label: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }, {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }>, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        context: string;
+        title: string;
+        decision_id: string;
+        choices: {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }[];
+    }, {
+        context: string;
+        title: string;
+        decision_id: string;
+        choices: {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }[];
+    }>, "many">;
+    auto_selected: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        decision_id: import("zod").ZodString;
+        auto_selected: import("zod").ZodEnum<["A", "B", "C"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        reason: string;
+        decision_id: string;
+        auto_selected: "A" | "B" | "C";
+    }, {
+        reason: string;
+        decision_id: string;
+        auto_selected: "A" | "B" | "C";
+    }>, "many">>;
+    next_action: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    decision_requests: {
+        context: string;
+        title: string;
+        decision_id: string;
+        choices: {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }[];
+    }[];
+    next_action?: any;
+    auto_selected?: {
+        reason: string;
+        decision_id: string;
+        auto_selected: "A" | "B" | "C";
+    }[] | undefined;
+}, {
+    project_id: string;
+    decision_requests: {
+        context: string;
+        title: string;
+        decision_id: string;
+        choices: {
+            key: "A" | "B" | "C" | "U";
+            label: string;
+            description?: string | undefined;
+        }[];
+    }[];
+    next_action?: any;
+    auto_selected?: {
+        reason: string;
+        decision_id: string;
+        auto_selected: "A" | "B" | "C";
+    }[] | undefined;
+}>;
+export declare const memoryStatusInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    docs_root: import("zod").ZodDefault<import("zod").ZodString>;
+    persist_dir: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    docs_root: string;
+    project_id?: string | undefined;
+    persist_dir?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    docs_root?: string | undefined;
+    persist_dir?: string | undefined;
+}>;
+export declare const memoryStatusOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    status: import("zod").ZodEnum<["READY", "NEEDS_SYNC", "OFFLINE_NO_INDEX", "ERROR"]>;
+    summary: import("zod").ZodString;
+    docs_root: import("zod").ZodString;
+    persist_dir: import("zod").ZodString;
+    collection: import("zod").ZodString;
+    stats: import("zod").ZodObject<{
+        document_count: import("zod").ZodNumber;
+        chunk_count: import("zod").ZodNumber;
+        last_sync_at: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        document_count: number;
+        chunk_count: number;
+        last_sync_at?: string | null | undefined;
+    }, {
+        document_count: number;
+        chunk_count: number;
+        last_sync_at?: string | null | undefined;
+    }>;
+    embedding: import("zod").ZodOptional<import("zod").ZodObject<{
+        backend: import("zod").ZodString;
+        model: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+        ready: import("zod").ZodBoolean;
+    }, "strict", import("zod").ZodTypeAny, {
+        ready: boolean;
+        backend: string;
+        model?: string | null | undefined;
+    }, {
+        ready: boolean;
+        backend: string;
+        model?: string | null | undefined;
+    }>>;
+    offline_mode: import("zod").ZodBoolean;
+    issues: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+}, "strict", import("zod").ZodTypeAny, {
+    status: "ERROR" | "READY" | "NEEDS_SYNC" | "OFFLINE_NO_INDEX";
+    issues: string[];
+    project_id: string;
+    summary: string;
+    docs_root: string;
+    persist_dir: string;
+    collection: string;
+    stats: {
+        document_count: number;
+        chunk_count: number;
+        last_sync_at?: string | null | undefined;
+    };
+    offline_mode: boolean;
+    next_action?: any;
+    embedding?: {
+        ready: boolean;
+        backend: string;
+        model?: string | null | undefined;
+    } | undefined;
+}, {
+    status: "ERROR" | "READY" | "NEEDS_SYNC" | "OFFLINE_NO_INDEX";
+    issues: string[];
+    project_id: string;
+    summary: string;
+    docs_root: string;
+    persist_dir: string;
+    collection: string;
+    stats: {
+        document_count: number;
+        chunk_count: number;
+        last_sync_at?: string | null | undefined;
+    };
+    offline_mode: boolean;
+    next_action?: any;
+    embedding?: {
+        ready: boolean;
+        backend: string;
+        model?: string | null | undefined;
+    } | undefined;
+}>;
+export declare const memorySyncInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    docs_root: import("zod").ZodDefault<import("zod").ZodString>;
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<["on_demand", "pre_finalize"]>>;
+    force_full: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    mode: "on_demand" | "pre_finalize";
+    docs_root: string;
+    force_full: boolean;
+    project_id?: string | undefined;
+}, {
+    mode?: "on_demand" | "pre_finalize" | undefined;
+    project_id?: string | undefined;
+    docs_root?: string | undefined;
+    force_full?: boolean | undefined;
+}>;
+export declare const memorySyncOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    status: import("zod").ZodEnum<["OK", "NO_CHANGES", "ERROR"]>;
+    summary: import("zod").ZodString;
+    docs_root: import("zod").ZodString;
+    persist_dir: import("zod").ZodString;
+    collection: import("zod").ZodString;
+    result: import("zod").ZodObject<{
+        scanned_files: import("zod").ZodNumber;
+        ingested_files: import("zod").ZodNumber;
+        updated_files: import("zod").ZodNumber;
+        skipped_files: import("zod").ZodNumber;
+        duration_ms: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        duration_ms: number;
+        updated_files: number;
+        scanned_files: number;
+        ingested_files: number;
+        skipped_files: number;
+    }, {
+        duration_ms: number;
+        updated_files: number;
+        scanned_files: number;
+        ingested_files: number;
+        skipped_files: number;
+    }>;
+    offline_mode: import("zod").ZodBoolean;
+    issues: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+}, "strict", import("zod").ZodTypeAny, {
+    status: "ERROR" | "OK" | "NO_CHANGES";
+    issues: string[];
+    project_id: string;
+    result: {
+        duration_ms: number;
+        updated_files: number;
+        scanned_files: number;
+        ingested_files: number;
+        skipped_files: number;
+    };
+    summary: string;
+    docs_root: string;
+    persist_dir: string;
+    collection: string;
+    offline_mode: boolean;
+    next_action?: any;
+}, {
+    status: "ERROR" | "OK" | "NO_CHANGES";
+    issues: string[];
+    project_id: string;
+    result: {
+        duration_ms: number;
+        updated_files: number;
+        scanned_files: number;
+        ingested_files: number;
+        skipped_files: number;
+    };
+    summary: string;
+    docs_root: string;
+    persist_dir: string;
+    collection: string;
+    offline_mode: boolean;
+    next_action?: any;
+}>;
+export declare const advisoryReviewInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<["triage", "quick", "thorough"]>>;
+    trigger: import("zod").ZodDefault<import("zod").ZodEnum<["on_demand", "pre_finalize", "pr_event"]>>;
+    budget: import("zod").ZodDefault<import("zod").ZodEnum<["low", "medium", "high"]>>;
+    changed_paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    target_paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    diff_context: import("zod").ZodOptional<import("zod").ZodString>;
+    base_sha: import("zod").ZodOptional<import("zod").ZodString>;
+    head_sha: import("zod").ZodOptional<import("zod").ZodString>;
+    focus: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<["BUSINESS_FIT", "ARCHITECTURE", "ALGO_REFACTOR"]>, "many">>;
+    product_intent_refs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+}, "strict", import("zod").ZodTypeAny, {
+    mode: "quick" | "thorough" | "triage";
+    trigger: "on_demand" | "pre_finalize" | "pr_event";
+    budget: "low" | "medium" | "high";
+    focus?: ("BUSINESS_FIT" | "ARCHITECTURE" | "ALGO_REFACTOR")[] | undefined;
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    target_paths?: string[] | undefined;
+    changed_paths?: string[] | undefined;
+    diff_context?: string | undefined;
+    base_sha?: string | undefined;
+    head_sha?: string | undefined;
+    product_intent_refs?: string[] | undefined;
+}, {
+    mode?: "quick" | "thorough" | "triage" | undefined;
+    focus?: ("BUSINESS_FIT" | "ARCHITECTURE" | "ALGO_REFACTOR")[] | undefined;
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    trigger?: "on_demand" | "pre_finalize" | "pr_event" | undefined;
+    target_paths?: string[] | undefined;
+    budget?: "low" | "medium" | "high" | undefined;
+    changed_paths?: string[] | undefined;
+    diff_context?: string | undefined;
+    base_sha?: string | undefined;
+    head_sha?: string | undefined;
+    product_intent_refs?: string[] | undefined;
+}>;
+export declare const advisoryReviewOutputSchema: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+export declare const activateInputSchema: import("zod").ZodObject<{
+    license_key: import("zod").ZodString;
+    force: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    app_version: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    license_key: string;
+    force: boolean;
+    app_version?: string | undefined;
+}, {
+    license_key: string;
+    force?: boolean | undefined;
+    app_version?: string | undefined;
+}>;
+export declare const activateOutputSchema: import("zod").ZodObject<{
+    status: import("zod").ZodEnum<["OK", "OFFLINE", "ERROR"]>;
+    summary: import("zod").ZodString;
+    token_file: import("zod").ZodString;
+    offline_mode: import("zod").ZodBoolean;
+    entitlements: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+    policy: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+    subject_id: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+    expires_at: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+    issues: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+}, "strict", import("zod").ZodTypeAny, {
+    status: "ERROR" | "OK" | "OFFLINE";
+    issues: string[];
+    summary: string;
+    offline_mode: boolean;
+    token_file: string;
+    policy?: any;
+    expires_at?: any;
+    entitlements?: any;
+    next_action?: any;
+    subject_id?: any;
+}, {
+    status: "ERROR" | "OK" | "OFFLINE";
+    issues: string[];
+    summary: string;
+    offline_mode: boolean;
+    token_file: string;
+    policy?: any;
+    expires_at?: any;
+    entitlements?: any;
+    next_action?: any;
+    subject_id?: any;
+}>;
+export declare const submitDecisionInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    decision_id: import("zod").ZodString;
+    choice: import("zod").ZodEnum<["A", "B", "C", "U"]>;
+    note: import("zod").ZodOptional<import("zod").ZodString>;
+    intent_type: import("zod").ZodOptional<import("zod").ZodEnum<["ARCH", "SPEC", "FORMAT", "BEHAVIOR", "FIX"]>>;
+    intent_why: import("zod").ZodOptional<import("zod").ZodString>;
+    intent_tradeoff: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    decision_id: string;
+    choice: "A" | "B" | "C" | "U";
+    project_id?: string | undefined;
+    note?: string | undefined;
+    intent_type?: "FIX" | "ARCH" | "SPEC" | "FORMAT" | "BEHAVIOR" | undefined;
+    intent_why?: string | undefined;
+    intent_tradeoff?: string | undefined;
+}, {
+    decision_id: string;
+    choice: "A" | "B" | "C" | "U";
+    project_id?: string | undefined;
+    note?: string | undefined;
+    intent_type?: "FIX" | "ARCH" | "SPEC" | "FORMAT" | "BEHAVIOR" | undefined;
+    intent_why?: string | undefined;
+    intent_tradeoff?: string | undefined;
+}>;
+export declare const submitDecisionOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    result: import("zod").ZodObject<{
+        decision_id: import("zod").ZodString;
+        chosen: import("zod").ZodEnum<["A", "B", "C", "U"]>;
+        summary: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        summary: string;
+        decision_id: string;
+        chosen: "A" | "B" | "C" | "U";
+    }, {
+        summary: string;
+        decision_id: string;
+        chosen: "A" | "B" | "C" | "U";
+    }>;
+    remaining_decisions: import("zod").ZodNumber;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.create_work_order", "vibe_pm.get_decision"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.get_decision" | "vibe_pm.create_work_order";
+        reason: string;
+    }, {
+        tool: "vibe_pm.get_decision" | "vibe_pm.create_work_order";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.get_decision" | "vibe_pm.create_work_order";
+        reason: string;
+    };
+    result: {
+        summary: string;
+        decision_id: string;
+        chosen: "A" | "B" | "C" | "U";
+    };
+    remaining_decisions: number;
+}, {
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.get_decision" | "vibe_pm.create_work_order";
+        reason: string;
+    };
+    result: {
+        summary: string;
+        decision_id: string;
+        chosen: "A" | "B" | "C" | "U";
+    };
+    remaining_decisions: number;
+}>;
+export declare const createWorkOrderInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    additional_instructions: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id?: string | undefined;
+    additional_instructions?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    additional_instructions?: string | undefined;
+}>;
+export declare const createWorkOrderOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    work_order: import("zod").ZodObject<{
+        headline: import("zod").ZodString;
+        scope: import("zod").ZodObject<{
+            include: import("zod").ZodArray<import("zod").ZodString, "many">;
+            exclude: import("zod").ZodArray<import("zod").ZodString, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            include: string[];
+            exclude: string[];
+        }, {
+            include: string[];
+            exclude: string[];
+        }>;
+        do_not_touch: import("zod").ZodArray<import("zod").ZodString, "many">;
+        verify_criteria: import("zod").ZodArray<import("zod").ZodString, "many">;
+        paste_to_agent: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        scope: {
+            include: string[];
+            exclude: string[];
+        };
+        do_not_touch: string[];
+        verify_criteria: string[];
+        headline: string;
+        paste_to_agent: string;
+    }, {
+        scope: {
+            include: string[];
+            exclude: string[];
+        };
+        do_not_touch: string[];
+        verify_criteria: string[];
+        headline: string;
+        paste_to_agent: string;
+    }>;
+    paths: import("zod").ZodObject<{
+        bridge_path: import("zod").ZodString;
+        intent_dir: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        bridge_path: string;
+        intent_dir?: string | undefined;
+    }, {
+        bridge_path: string;
+        intent_dir?: string | undefined;
+    }>;
+    modules: import("zod").ZodObject<{
+        research: import("zod").ZodObject<{
+            version: import("zod").ZodLiteral<"v1">;
+            fingerprint: import("zod").ZodString;
+            path: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }>;
+        skills: import("zod").ZodObject<{
+            version: import("zod").ZodLiteral<"v1">;
+            fingerprint: import("zod").ZodString;
+            path: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }>;
+        planning: import("zod").ZodObject<{
+            version: import("zod").ZodLiteral<"v1">;
+            fingerprint: import("zod").ZodString;
+            path: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }, {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        }>;
+    }, "strict", import("zod").ZodTypeAny, {
+        skills: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        research: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        planning: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+    }, {
+        skills: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        research: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        planning: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+    }>;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.inspect_code">;
+        reason: import("zod").ZodString;
+        when: import("zod").ZodLiteral<"after_implementation">;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.inspect_code";
+        reason: string;
+        when: "after_implementation";
+    }, {
+        tool: "vibe_pm.inspect_code";
+        reason: string;
+        when: "after_implementation";
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    run_id: string;
+    paths: {
+        bridge_path: string;
+        intent_dir?: string | undefined;
+    };
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.inspect_code";
+        reason: string;
+        when: "after_implementation";
+    };
+    work_order: {
+        scope: {
+            include: string[];
+            exclude: string[];
+        };
+        do_not_touch: string[];
+        verify_criteria: string[];
+        headline: string;
+        paste_to_agent: string;
+    };
+    modules: {
+        skills: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        research: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        planning: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+    };
+}, {
+    run_id: string;
+    paths: {
+        bridge_path: string;
+        intent_dir?: string | undefined;
+    };
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.inspect_code";
+        reason: string;
+        when: "after_implementation";
+    };
+    work_order: {
+        scope: {
+            include: string[];
+            exclude: string[];
+        };
+        do_not_touch: string[];
+        verify_criteria: string[];
+        headline: string;
+        paste_to_agent: string;
+    };
+    modules: {
+        skills: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        research: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+        planning: {
+            version: "v1";
+            path: string;
+            fingerprint: string;
+        };
+    };
+}>;
+export declare const inspectCodeInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    target_paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    bridge_path: import("zod").ZodOptional<import("zod").ZodString>;
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<["quick", "thorough"]>>;
+    auto_fix: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    run_build: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    build_steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        cmd: import("zod").ZodString;
+        continueOnFailure: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    }, "strip", import("zod").ZodTypeAny, {
+        name: string;
+        cmd: string;
+        continueOnFailure?: boolean | undefined;
+    }, {
+        name: string;
+        cmd: string;
+        continueOnFailure?: boolean | undefined;
+    }>, "many">>;
+    review_stage: import("zod").ZodDefault<import("zod").ZodEnum<["full", "spec_compliance", "code_quality"]>>;
+}, "strict", import("zod").ZodTypeAny, {
+    mode: "quick" | "thorough";
+    auto_fix: boolean;
+    run_build: boolean;
+    review_stage: "full" | "spec_compliance" | "code_quality";
+    project_id?: string | undefined;
+    bridge_path?: string | undefined;
+    target_paths?: string[] | undefined;
+    build_steps?: {
+        name: string;
+        cmd: string;
+        continueOnFailure?: boolean | undefined;
+    }[] | undefined;
+}, {
+    mode?: "quick" | "thorough" | undefined;
+    auto_fix?: boolean | undefined;
+    project_id?: string | undefined;
+    bridge_path?: string | undefined;
+    target_paths?: string[] | undefined;
+    run_build?: boolean | undefined;
+    build_steps?: {
+        name: string;
+        cmd: string;
+        continueOnFailure?: boolean | undefined;
+    }[] | undefined;
+    review_stage?: "full" | "spec_compliance" | "code_quality" | undefined;
+}>;
+export declare const inspectCodeOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    review_summary: import("zod").ZodObject<{
+        decision_context: import("zod").ZodString;
+        review_result: import("zod").ZodEnum<["GO", "FIX", "BLOCK"]>;
+        one_line_verdict: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        decision_context: string;
+        review_result: "GO" | "FIX" | "BLOCK";
+        one_line_verdict: string;
+    }, {
+        decision_context: string;
+        review_result: "GO" | "FIX" | "BLOCK";
+        one_line_verdict: string;
+    }>;
+    issues_found: import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodEnum<["RULE_VIOLATION", "VERIFY_FAIL", "SCOPE_MISMATCH", "RISK_SPIKE"]>;
+        business_risk: import("zod").ZodString;
+        plain_explanation: import("zod").ZodString;
+        technical_detail: import("zod").ZodOptional<import("zod").ZodObject<{
+            file_path: import("zod").ZodString;
+            line_range: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNumber, "many">>;
+            rule_violated: import("zod").ZodOptional<import("zod").ZodString>;
+            principle_id: import("zod").ZodOptional<import("zod").ZodEnum<["STRATEGY_ENFORCEMENT", "ADAPTER_ENFORCEMENT", "OBSERVER_ENFORCEMENT", "BUILDER_ENFORCEMENT", "SINGLETON_GUARD", "UNMAPPED_RULE"]>>;
+            pattern: import("zod").ZodOptional<import("zod").ZodEnum<["Strategy", "Adapter", "Observer", "Builder", "Singleton"]>>;
+            rule_engine: import("zod").ZodOptional<import("zod").ZodLiteral<"semgrep">>;
+            rule_id: import("zod").ZodOptional<import("zod").ZodString>;
+            severity: import("zod").ZodOptional<import("zod").ZodEnum<["ERROR", "WARNING", "INFO", "CRITICAL"]>>;
+            evidence_ref: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        }, {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        type: "RULE_VIOLATION" | "VERIFY_FAIL" | "SCOPE_MISMATCH" | "RISK_SPIKE";
+        business_risk: string;
+        plain_explanation: string;
+        technical_detail?: {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        } | undefined;
+    }, {
+        type: "RULE_VIOLATION" | "VERIFY_FAIL" | "SCOPE_MISMATCH" | "RISK_SPIKE";
+        business_risk: string;
+        plain_explanation: string;
+        technical_detail?: {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        } | undefined;
+    }>, "many">;
+    fixed_issues: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodString;
+        description: import("zod").ZodString;
+        file: import("zod").ZodOptional<import("zod").ZodString>;
+        status: import("zod").ZodLiteral<"FIXED">;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "FIXED";
+        type: string;
+        description: string;
+        file?: string | undefined;
+    }, {
+        status: "FIXED";
+        type: string;
+        description: string;
+        file?: string | undefined;
+    }>, "many">>;
+    next_action: import("zod").ZodEffects<import("zod").ZodAny, any, any>;
+    message_template_id: import("zod").ZodEnum<["GO-01", "GO-02", "FIX-01", "FIX-02", "BLOCK-01", "BLOCK-02", "AUTO-01", "AUTO-02", "AUTO-03", "DEPS-01", "DEPS-02", "DEPS-03", "VERIFY-01", "VERIFY-02", "VERIFY-03"]>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    review_summary: {
+        decision_context: string;
+        review_result: "GO" | "FIX" | "BLOCK";
+        one_line_verdict: string;
+    };
+    issues_found: {
+        type: "RULE_VIOLATION" | "VERIFY_FAIL" | "SCOPE_MISMATCH" | "RISK_SPIKE";
+        business_risk: string;
+        plain_explanation: string;
+        technical_detail?: {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        } | undefined;
+    }[];
+    message_template_id: "GO-01" | "GO-02" | "FIX-01" | "FIX-02" | "BLOCK-01" | "BLOCK-02" | "AUTO-01" | "AUTO-02" | "AUTO-03" | "DEPS-01" | "DEPS-02" | "DEPS-03" | "VERIFY-01" | "VERIFY-02" | "VERIFY-03";
+    next_action?: any;
+    fixed_issues?: {
+        status: "FIXED";
+        type: string;
+        description: string;
+        file?: string | undefined;
+    }[] | undefined;
+}, {
+    project_id: string;
+    review_summary: {
+        decision_context: string;
+        review_result: "GO" | "FIX" | "BLOCK";
+        one_line_verdict: string;
+    };
+    issues_found: {
+        type: "RULE_VIOLATION" | "VERIFY_FAIL" | "SCOPE_MISMATCH" | "RISK_SPIKE";
+        business_risk: string;
+        plain_explanation: string;
+        technical_detail?: {
+            file_path: string;
+            severity?: "ERROR" | "WARNING" | "INFO" | "CRITICAL" | undefined;
+            pattern?: "Strategy" | "Adapter" | "Observer" | "Builder" | "Singleton" | undefined;
+            line_range?: number[] | undefined;
+            rule_violated?: string | undefined;
+            principle_id?: "STRATEGY_ENFORCEMENT" | "ADAPTER_ENFORCEMENT" | "OBSERVER_ENFORCEMENT" | "BUILDER_ENFORCEMENT" | "SINGLETON_GUARD" | "UNMAPPED_RULE" | undefined;
+            rule_engine?: "semgrep" | undefined;
+            rule_id?: string | undefined;
+            evidence_ref?: string | undefined;
+        } | undefined;
+    }[];
+    message_template_id: "GO-01" | "GO-02" | "FIX-01" | "FIX-02" | "BLOCK-01" | "BLOCK-02" | "AUTO-01" | "AUTO-02" | "AUTO-03" | "DEPS-01" | "DEPS-02" | "DEPS-03" | "VERIFY-01" | "VERIFY-02" | "VERIFY-03";
+    next_action?: any;
+    fixed_issues?: {
+        status: "FIXED";
+        type: string;
+        description: string;
+        file?: string | undefined;
+    }[] | undefined;
+}>;
+export declare const statusInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    format: import("zod").ZodOptional<import("zod").ZodEnum<["json", "summary"]>>;
+}, "strict", import("zod").ZodTypeAny, {
+    format?: "json" | "summary" | undefined;
+    project_id?: string | undefined;
+}, {
+    format?: "json" | "summary" | undefined;
+    project_id?: string | undefined;
+}>;
+export declare const statusOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    project: import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        mode: import("zod").ZodString;
+        started_at: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        mode: string;
+        name: string;
+        started_at: string;
+    }, {
+        mode: string;
+        name: string;
+        started_at: string;
+    }>;
+    current_state: import("zod").ZodObject<{
+        phase: import("zod").ZodString;
+        decisions_made: import("zod").ZodNumber;
+        decisions_pending: import("zod").ZodNumber;
+        last_review_status: import("zod").ZodOptional<import("zod").ZodEnum<["GO", "FIX", "BLOCK"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        phase: string;
+        decisions_made: number;
+        decisions_pending: number;
+        last_review_status?: "GO" | "FIX" | "BLOCK" | undefined;
+    }, {
+        phase: string;
+        decisions_made: number;
+        decisions_pending: number;
+        last_review_status?: "GO" | "FIX" | "BLOCK" | undefined;
+    }>;
+    risks: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodString;
+        label: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: string;
+        label: string;
+    }, {
+        tool: string;
+        label: string;
+    }>;
+    observer: import("zod").ZodOptional<import("zod").ZodObject<{
+        state: import("zod").ZodString;
+        watcher_mode: import("zod").ZodOptional<import("zod").ZodString>;
+        workspace_path: import("zod").ZodOptional<import("zod").ZodString>;
+        is_attached: import("zod").ZodBoolean;
+        files_watched: import("zod").ZodOptional<import("zod").ZodNumber>;
+        active_risks: import("zod").ZodOptional<import("zod").ZodNumber>;
+        warning: import("zod").ZodOptional<import("zod").ZodString>;
+        heartbeat_is_alive: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        heartbeat_age_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        heartbeat_reason: import("zod").ZodOptional<import("zod").ZodString>;
+        delta_loop_running: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        delta_loop_interval_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        delta_loop_in_flight: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        runtime_watcher_impl: import("zod").ZodOptional<import("zod").ZodString>;
+        enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        mode: import("zod").ZodOptional<import("zod").ZodEnum<["off", "soft", "watch"]>>;
+        health: import("zod").ZodOptional<import("zod").ZodEnum<["ok", "degraded", "stopped"]>>;
+        started_at: import("zod").ZodOptional<import("zod").ZodString>;
+        last_heartbeat_at: import("zod").ZodOptional<import("zod").ZodString>;
+        heartbeat_period_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        last_scan_at: import("zod").ZodOptional<import("zod").ZodString>;
+        last_scan_duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+        last_error: import("zod").ZodOptional<import("zod").ZodObject<{
+            code: import("zod").ZodString;
+            message: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            code: string;
+            message: string;
+        }, {
+            code: string;
+            message: string;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        state: string;
+        is_attached: boolean;
+        mode?: "off" | "soft" | "watch" | undefined;
+        warning?: string | undefined;
+        health?: "ok" | "degraded" | "stopped" | undefined;
+        enabled?: boolean | undefined;
+        watcher_mode?: string | undefined;
+        workspace_path?: string | undefined;
+        files_watched?: number | undefined;
+        active_risks?: number | undefined;
+        heartbeat_is_alive?: boolean | undefined;
+        heartbeat_age_ms?: number | undefined;
+        heartbeat_reason?: string | undefined;
+        delta_loop_running?: boolean | undefined;
+        delta_loop_interval_ms?: number | undefined;
+        delta_loop_in_flight?: boolean | undefined;
+        runtime_watcher_impl?: string | undefined;
+        started_at?: string | undefined;
+        last_heartbeat_at?: string | undefined;
+        heartbeat_period_ms?: number | undefined;
+        last_scan_at?: string | undefined;
+        last_scan_duration_ms?: number | undefined;
+        last_error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }, {
+        state: string;
+        is_attached: boolean;
+        mode?: "off" | "soft" | "watch" | undefined;
+        warning?: string | undefined;
+        health?: "ok" | "degraded" | "stopped" | undefined;
+        enabled?: boolean | undefined;
+        watcher_mode?: string | undefined;
+        workspace_path?: string | undefined;
+        files_watched?: number | undefined;
+        active_risks?: number | undefined;
+        heartbeat_is_alive?: boolean | undefined;
+        heartbeat_age_ms?: number | undefined;
+        heartbeat_reason?: string | undefined;
+        delta_loop_running?: boolean | undefined;
+        delta_loop_interval_ms?: number | undefined;
+        delta_loop_in_flight?: boolean | undefined;
+        runtime_watcher_impl?: string | undefined;
+        started_at?: string | undefined;
+        last_heartbeat_at?: string | undefined;
+        heartbeat_period_ms?: number | undefined;
+        last_scan_at?: string | undefined;
+        last_scan_duration_ms?: number | undefined;
+        last_error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    }>>;
+    ingress: import("zod").ZodOptional<import("zod").ZodObject<{
+        state: import("zod").ZodEnum<["ready", "stale", "missing", "failed"]>;
+        required: import("zod").ZodBoolean;
+        artifacts: import("zod").ZodObject<{
+            ingress_summary: import("zod").ZodObject<{
+                exists: import("zod").ZodBoolean;
+                path: import("zod").ZodString;
+            }, "strict", import("zod").ZodTypeAny, {
+                path: string;
+                exists: boolean;
+            }, {
+                path: string;
+                exists: boolean;
+            }>;
+            ingress_resolution: import("zod").ZodOptional<import("zod").ZodObject<{
+                exists: import("zod").ZodBoolean;
+                path: import("zod").ZodString;
+            }, "strict", import("zod").ZodTypeAny, {
+                path: string;
+                exists: boolean;
+            }, {
+                path: string;
+                exists: boolean;
+            }>>;
+            project_fingerprint: import("zod").ZodOptional<import("zod").ZodObject<{
+                exists: import("zod").ZodBoolean;
+                path: import("zod").ZodString;
+            }, "strict", import("zod").ZodTypeAny, {
+                path: string;
+                exists: boolean;
+            }, {
+                path: string;
+                exists: boolean;
+            }>>;
+        }, "strict", import("zod").ZodTypeAny, {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        }, {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        }>;
+        dirty: import("zod").ZodObject<{
+            is_dirty: import("zod").ZodBoolean;
+            reasons: import("zod").ZodArray<import("zod").ZodObject<{
+                code: import("zod").ZodEnum<["mtime_changed", "file_count_changed", "lockfile_changed", "config_changed", "unknown"]>;
+                detail: import("zod").ZodOptional<import("zod").ZodString>;
+            }, "strict", import("zod").ZodTypeAny, {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }, {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }>, "many">;
+        }, "strict", import("zod").ZodTypeAny, {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        }, {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        }>;
+        next_action: import("zod").ZodOptional<import("zod").ZodObject<{
+            tool: import("zod").ZodLiteral<"vibe_pm.ingress">;
+            input: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+        }, "strict", import("zod").ZodTypeAny, {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        }, {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        artifacts: {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        };
+        dirty: {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        };
+        state: "ready" | "missing" | "failed" | "stale";
+        required: boolean;
+        next_action?: {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        } | undefined;
+    }, {
+        artifacts: {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        };
+        dirty: {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        };
+        state: "ready" | "missing" | "failed" | "stale";
+        required: boolean;
+        next_action?: {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        } | undefined;
+    }>>;
+    dirty: import("zod").ZodOptional<import("zod").ZodObject<{
+        is_dirty: import("zod").ZodBoolean;
+        confidence: import("zod").ZodEnum<["low", "medium", "high"]>;
+        reasons: import("zod").ZodArray<import("zod").ZodObject<{
+            code: import("zod").ZodEnum<["mtime_changed", "file_count_changed", "lockfile_changed", "config_changed", "unknown"]>;
+            detail: import("zod").ZodOptional<import("zod").ZodString>;
+            sample_paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "strict", import("zod").ZodTypeAny, {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }, {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }>, "many">;
+        computed_at: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        reasons: {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }[];
+        confidence: "low" | "medium" | "high";
+        is_dirty: boolean;
+        computed_at: string;
+    }, {
+        reasons: {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }[];
+        confidence: "low" | "medium" | "high";
+        is_dirty: boolean;
+        computed_at: string;
+    }>>;
+    feature_flags: import("zod").ZodOptional<import("zod").ZodObject<{
+        autonomy_mode: import("zod").ZodEnum<["off", "assisted", "full"]>;
+        observer_enabled: import("zod").ZodBoolean;
+        observer_watch: import("zod").ZodBoolean;
+        ingress_required: import("zod").ZodBoolean;
+    }, "strict", import("zod").ZodTypeAny, {
+        autonomy_mode: "full" | "off" | "assisted";
+        observer_enabled: boolean;
+        observer_watch: boolean;
+        ingress_required: boolean;
+    }, {
+        autonomy_mode: "full" | "off" | "assisted";
+        observer_enabled: boolean;
+        observer_watch: boolean;
+        ingress_required: boolean;
+    }>>;
+    bitnet: import("zod").ZodOptional<import("zod").ZodObject<{
+        enabled: import("zod").ZodBoolean;
+        cache_exists: import("zod").ZodBoolean;
+        stale: import("zod").ZodBoolean;
+        last_check: import("zod").ZodOptional<import("zod").ZodObject<{
+            checked_at: import("zod").ZodString;
+            verdict: import("zod").ZodEnum<["GO", "WARNING", "BLOCK"]>;
+            evidence_level: import("zod").ZodEnum<["NONE", "RULE", "MODEL"]>;
+            risk_tags: import("zod").ZodArray<import("zod").ZodString, "many">;
+            reason: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        }, {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        }>>;
+        warning: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        enabled: boolean;
+        stale: boolean;
+        cache_exists: boolean;
+        warning?: string | undefined;
+        last_check?: {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        } | undefined;
+    }, {
+        enabled: boolean;
+        stale: boolean;
+        cache_exists: boolean;
+        warning?: string | undefined;
+        last_check?: {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        } | undefined;
+    }>>;
+    tier: import("zod").ZodOptional<import("zod").ZodObject<{
+        plan: import("zod").ZodEnum<["FREE", "PRO"]>;
+        status: import("zod").ZodEnum<["ACTIVE", "EXPIRED", "INVALID", "MISSING"]>;
+        days_left: import("zod").ZodOptional<import("zod").ZodNumber>;
+        concurrent_slots: import("zod").ZodObject<{
+            free: import("zod").ZodNumber;
+            paid: import("zod").ZodNumber;
+        }, "strict", import("zod").ZodTypeAny, {
+            free: number;
+            paid: number;
+        }, {
+            free: number;
+            paid: number;
+        }>;
+        features: import("zod").ZodObject<{
+            scorecard: import("zod").ZodBoolean;
+            policy_analysis: import("zod").ZodBoolean;
+            auto_fix: import("zod").ZodBoolean;
+            bitnet_trace: import("zod").ZodBoolean;
+        }, "strict", import("zod").ZodTypeAny, {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        }, {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        }>;
+        upgrade_hint: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "MISSING" | "ACTIVE" | "EXPIRED" | "INVALID";
+        plan: "FREE" | "PRO";
+        concurrent_slots: {
+            free: number;
+            paid: number;
+        };
+        features: {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        };
+        days_left?: number | undefined;
+        upgrade_hint?: string | undefined;
+    }, {
+        status: "MISSING" | "ACTIVE" | "EXPIRED" | "INVALID";
+        plan: "FREE" | "PRO";
+        concurrent_slots: {
+            free: number;
+            paid: number;
+        };
+        features: {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        };
+        days_left?: number | undefined;
+        upgrade_hint?: string | undefined;
+    }>>;
+    trigger: import("zod").ZodOptional<import("zod").ZodObject<{
+        active_triggers: import("zod").ZodArray<import("zod").ZodString, "many">;
+        highest_priority: import("zod").ZodNullable<import("zod").ZodString>;
+        cooldown_blocks: import("zod").ZodArray<import("zod").ZodString, "many">;
+        engine_backlog: import("zod").ZodBoolean;
+        last_evaluation: import("zod").ZodNullable<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        active_triggers: string[];
+        highest_priority: string | null;
+        cooldown_blocks: string[];
+        engine_backlog: boolean;
+        last_evaluation: string | null;
+    }, {
+        active_triggers: string[];
+        highest_priority: string | null;
+        cooldown_blocks: string[];
+        engine_backlog: boolean;
+        last_evaluation: string | null;
+    }>>;
+    preprocess: import("zod").ZodOptional<import("zod").ZodObject<{
+        summary: import("zod").ZodOptional<import("zod").ZodString>;
+        unified_verdict_summary: import("zod").ZodOptional<import("zod").ZodString>;
+        airlock: import("zod").ZodOptional<import("zod").ZodObject<{
+            report_path: import("zod").ZodOptional<import("zod").ZodString>;
+            safe_context_path: import("zod").ZodOptional<import("zod").ZodString>;
+            fingerprint_path: import("zod").ZodOptional<import("zod").ZodString>;
+            redacted_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            rules_applied: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            policy_name: import("zod").ZodOptional<import("zod").ZodString>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        }, {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        }>>;
+        router: import("zod").ZodOptional<import("zod").ZodObject<{
+            decision_path: import("zod").ZodOptional<import("zod").ZodString>;
+            route: import("zod").ZodOptional<import("zod").ZodEnum<["local_only", "local_then_cloud", "cloud_direct"]>>;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            policy_id: import("zod").ZodOptional<import("zod").ZodString>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        }, {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        }>>;
+        chunking: import("zod").ZodOptional<import("zod").ZodObject<{
+            manifest_path: import("zod").ZodOptional<import("zod").ZodString>;
+            chunk_count: import("zod").ZodOptional<import("zod").ZodNumber>;
+            profiles: import("zod").ZodOptional<import("zod").ZodObject<{
+                extraction: import("zod").ZodOptional<import("zod").ZodNumber>;
+                reasoning: import("zod").ZodOptional<import("zod").ZodNumber>;
+                reference: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, "strict", import("zod").ZodTypeAny, {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            }, {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            }>>;
+            created_at: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "strict", import("zod").ZodTypeAny, {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        }, {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        }>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        summary?: string | undefined;
+        airlock?: {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        } | undefined;
+        unified_verdict_summary?: string | undefined;
+        router?: {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        } | undefined;
+        chunking?: {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        summary?: string | undefined;
+        airlock?: {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        } | undefined;
+        unified_verdict_summary?: string | undefined;
+        router?: {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        } | undefined;
+        chunking?: {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        } | undefined;
+    }>>;
+    packs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        version: import("zod").ZodString;
+        active: import("zod").ZodBoolean;
+        tools: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        version: string;
+        id: string;
+        active: boolean;
+        tools: number;
+    }, {
+        version: string;
+        id: string;
+        active: boolean;
+        tools: number;
+    }>, "many">>;
+}, "strict", import("zod").ZodTypeAny, {
+    project: {
+        mode: string;
+        name: string;
+        started_at: string;
+    };
+    project_id: string;
+    next_action: {
+        tool: string;
+        label: string;
+    };
+    risks: string[];
+    current_state: {
+        phase: string;
+        decisions_made: number;
+        decisions_pending: number;
+        last_review_status?: "GO" | "FIX" | "BLOCK" | undefined;
+    };
+    bitnet?: {
+        enabled: boolean;
+        stale: boolean;
+        cache_exists: boolean;
+        warning?: string | undefined;
+        last_check?: {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        } | undefined;
+    } | undefined;
+    observer?: {
+        state: string;
+        is_attached: boolean;
+        mode?: "off" | "soft" | "watch" | undefined;
+        warning?: string | undefined;
+        health?: "ok" | "degraded" | "stopped" | undefined;
+        enabled?: boolean | undefined;
+        watcher_mode?: string | undefined;
+        workspace_path?: string | undefined;
+        files_watched?: number | undefined;
+        active_risks?: number | undefined;
+        heartbeat_is_alive?: boolean | undefined;
+        heartbeat_age_ms?: number | undefined;
+        heartbeat_reason?: string | undefined;
+        delta_loop_running?: boolean | undefined;
+        delta_loop_interval_ms?: number | undefined;
+        delta_loop_in_flight?: boolean | undefined;
+        runtime_watcher_impl?: string | undefined;
+        started_at?: string | undefined;
+        last_heartbeat_at?: string | undefined;
+        heartbeat_period_ms?: number | undefined;
+        last_scan_at?: string | undefined;
+        last_scan_duration_ms?: number | undefined;
+        last_error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    dirty?: {
+        reasons: {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }[];
+        confidence: "low" | "medium" | "high";
+        is_dirty: boolean;
+        computed_at: string;
+    } | undefined;
+    trigger?: {
+        active_triggers: string[];
+        highest_priority: string | null;
+        cooldown_blocks: string[];
+        engine_backlog: boolean;
+        last_evaluation: string | null;
+    } | undefined;
+    ingress?: {
+        artifacts: {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        };
+        dirty: {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        };
+        state: "ready" | "missing" | "failed" | "stale";
+        required: boolean;
+        next_action?: {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        } | undefined;
+    } | undefined;
+    feature_flags?: {
+        autonomy_mode: "full" | "off" | "assisted";
+        observer_enabled: boolean;
+        observer_watch: boolean;
+        ingress_required: boolean;
+    } | undefined;
+    tier?: {
+        status: "MISSING" | "ACTIVE" | "EXPIRED" | "INVALID";
+        plan: "FREE" | "PRO";
+        concurrent_slots: {
+            free: number;
+            paid: number;
+        };
+        features: {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        };
+        days_left?: number | undefined;
+        upgrade_hint?: string | undefined;
+    } | undefined;
+    preprocess?: {
+        summary?: string | undefined;
+        airlock?: {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        } | undefined;
+        unified_verdict_summary?: string | undefined;
+        router?: {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        } | undefined;
+        chunking?: {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    packs?: {
+        version: string;
+        id: string;
+        active: boolean;
+        tools: number;
+    }[] | undefined;
+}, {
+    project: {
+        mode: string;
+        name: string;
+        started_at: string;
+    };
+    project_id: string;
+    next_action: {
+        tool: string;
+        label: string;
+    };
+    risks: string[];
+    current_state: {
+        phase: string;
+        decisions_made: number;
+        decisions_pending: number;
+        last_review_status?: "GO" | "FIX" | "BLOCK" | undefined;
+    };
+    bitnet?: {
+        enabled: boolean;
+        stale: boolean;
+        cache_exists: boolean;
+        warning?: string | undefined;
+        last_check?: {
+            verdict: "GO" | "BLOCK" | "WARNING";
+            reason: string;
+            risk_tags: string[];
+            checked_at: string;
+            evidence_level: "NONE" | "RULE" | "MODEL";
+        } | undefined;
+    } | undefined;
+    observer?: {
+        state: string;
+        is_attached: boolean;
+        mode?: "off" | "soft" | "watch" | undefined;
+        warning?: string | undefined;
+        health?: "ok" | "degraded" | "stopped" | undefined;
+        enabled?: boolean | undefined;
+        watcher_mode?: string | undefined;
+        workspace_path?: string | undefined;
+        files_watched?: number | undefined;
+        active_risks?: number | undefined;
+        heartbeat_is_alive?: boolean | undefined;
+        heartbeat_age_ms?: number | undefined;
+        heartbeat_reason?: string | undefined;
+        delta_loop_running?: boolean | undefined;
+        delta_loop_interval_ms?: number | undefined;
+        delta_loop_in_flight?: boolean | undefined;
+        runtime_watcher_impl?: string | undefined;
+        started_at?: string | undefined;
+        last_heartbeat_at?: string | undefined;
+        heartbeat_period_ms?: number | undefined;
+        last_scan_at?: string | undefined;
+        last_scan_duration_ms?: number | undefined;
+        last_error?: {
+            code: string;
+            message: string;
+        } | undefined;
+    } | undefined;
+    dirty?: {
+        reasons: {
+            code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+            detail?: string | undefined;
+            sample_paths?: string[] | undefined;
+        }[];
+        confidence: "low" | "medium" | "high";
+        is_dirty: boolean;
+        computed_at: string;
+    } | undefined;
+    trigger?: {
+        active_triggers: string[];
+        highest_priority: string | null;
+        cooldown_blocks: string[];
+        engine_backlog: boolean;
+        last_evaluation: string | null;
+    } | undefined;
+    ingress?: {
+        artifacts: {
+            ingress_summary: {
+                path: string;
+                exists: boolean;
+            };
+            ingress_resolution?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+            project_fingerprint?: {
+                path: string;
+                exists: boolean;
+            } | undefined;
+        };
+        dirty: {
+            reasons: {
+                code: "unknown" | "mtime_changed" | "file_count_changed" | "lockfile_changed" | "config_changed";
+                detail?: string | undefined;
+            }[];
+            is_dirty: boolean;
+        };
+        state: "ready" | "missing" | "failed" | "stale";
+        required: boolean;
+        next_action?: {
+            tool: "vibe_pm.ingress";
+            input: Record<string, unknown>;
+        } | undefined;
+    } | undefined;
+    feature_flags?: {
+        autonomy_mode: "full" | "off" | "assisted";
+        observer_enabled: boolean;
+        observer_watch: boolean;
+        ingress_required: boolean;
+    } | undefined;
+    tier?: {
+        status: "MISSING" | "ACTIVE" | "EXPIRED" | "INVALID";
+        plan: "FREE" | "PRO";
+        concurrent_slots: {
+            free: number;
+            paid: number;
+        };
+        features: {
+            auto_fix: boolean;
+            scorecard: boolean;
+            policy_analysis: boolean;
+            bitnet_trace: boolean;
+        };
+        days_left?: number | undefined;
+        upgrade_hint?: string | undefined;
+    } | undefined;
+    preprocess?: {
+        summary?: string | undefined;
+        airlock?: {
+            created_at?: string | undefined;
+            report_path?: string | undefined;
+            safe_context_path?: string | undefined;
+            fingerprint_path?: string | undefined;
+            redacted_count?: number | undefined;
+            rules_applied?: string[] | undefined;
+            policy_name?: string | undefined;
+        } | undefined;
+        unified_verdict_summary?: string | undefined;
+        router?: {
+            reason?: string | undefined;
+            created_at?: string | undefined;
+            route?: "local_only" | "local_then_cloud" | "cloud_direct" | undefined;
+            decision_path?: string | undefined;
+            policy_id?: string | undefined;
+        } | undefined;
+        chunking?: {
+            created_at?: string | undefined;
+            chunk_count?: number | undefined;
+            manifest_path?: string | undefined;
+            profiles?: {
+                reasoning?: number | undefined;
+                extraction?: number | undefined;
+                reference?: number | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+    packs?: {
+        version: string;
+        id: string;
+        active: boolean;
+        tools: number;
+    }[] | undefined;
+}>;
+export declare const repairPlanInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    use_latest_result: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    use_latest_result: boolean;
+    project_id?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    use_latest_result?: boolean | undefined;
+}>;
+export declare const repairPlanOutputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    problem_summary: import("zod").ZodObject<{
+        what_failed: import("zod").ZodString;
+        why_it_matters: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        what_failed: string;
+        why_it_matters: string;
+    }, {
+        what_failed: string;
+        why_it_matters: string;
+    }>;
+    repair_prompt: import("zod").ZodString;
+    next_action: import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"COPY_PASTE_TO_AGENT">;
+        label: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        type: "COPY_PASTE_TO_AGENT";
+        label: string;
+    }, {
+        type: "COPY_PASTE_TO_AGENT";
+        label: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    next_action: {
+        type: "COPY_PASTE_TO_AGENT";
+        label: string;
+    };
+    problem_summary: {
+        what_failed: string;
+        why_it_matters: string;
+    };
+    repair_prompt: string;
+}, {
+    project_id: string;
+    next_action: {
+        type: "COPY_PASTE_TO_AGENT";
+        label: string;
+    };
+    problem_summary: {
+        what_failed: string;
+        why_it_matters: string;
+    };
+    repair_prompt: string;
+}>;
+export declare const scaffoldInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    template: import("zod").ZodDefault<import("zod").ZodEnum<["minimal", "standard", "python_cli", "node_api"]>>;
+    force: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    force: boolean;
+    template: "python_cli" | "minimal" | "standard" | "node_api";
+    project_id?: string | undefined;
+}, {
+    project_id?: string | undefined;
+    force?: boolean | undefined;
+    template?: "python_cli" | "minimal" | "standard" | "node_api" | undefined;
+}>;
+export declare const scaffoldOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    created_paths: import("zod").ZodArray<import("zod").ZodString, "many">;
+    skipped_paths: import("zod").ZodArray<import("zod").ZodString, "many">;
+    structure_tree: import("zod").ZodString;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.briefing", "vibe_pm.scaffold"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.briefing" | "vibe_pm.scaffold";
+        reason: string;
+    }, {
+        tool: "vibe_pm.briefing" | "vibe_pm.scaffold";
+        reason: string;
+    }>;
+    error: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    next_action: {
+        tool: "vibe_pm.briefing" | "vibe_pm.scaffold";
+        reason: string;
+    };
+    created_paths: string[];
+    skipped_paths: string[];
+    structure_tree: string;
+    error?: string | undefined;
+}, {
+    success: boolean;
+    next_action: {
+        tool: "vibe_pm.briefing" | "vibe_pm.scaffold";
+        reason: string;
+    };
+    created_paths: string[];
+    skipped_paths: string[];
+    structure_tree: string;
+    error?: string | undefined;
+}>;
+export declare const finalizeWorkInputSchema: import("zod").ZodObject<{
+    task_summary: import("zod").ZodString;
+    spec_changes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        section: import("zod").ZodString;
+        content: import("zod").ZodString;
+        action: import("zod").ZodDefault<import("zod").ZodEnum<["REPLACE", "APPEND"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        content: string;
+        action: "REPLACE" | "APPEND";
+        section: string;
+    }, {
+        content: string;
+        section: string;
+        action?: "REPLACE" | "APPEND" | undefined;
+    }>, "many">>;
+    completed_plan_path: import("zod").ZodOptional<import("zod").ZodString>;
+    git_commit: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<["feat", "fix", "docs", "style", "refactor", "test", "chore"]>;
+        scope: import("zod").ZodOptional<import("zod").ZodString>;
+        subject: import("zod").ZodString;
+        body: import("zod").ZodOptional<import("zod").ZodString>;
+        footer: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        type: "fix" | "docs" | "test" | "feat" | "style" | "refactor" | "chore";
+        subject: string;
+        scope?: string | undefined;
+        body?: string | undefined;
+        footer?: string | undefined;
+    }, {
+        type: "fix" | "docs" | "test" | "feat" | "style" | "refactor" | "chore";
+        subject: string;
+        scope?: string | undefined;
+        body?: string | undefined;
+        footer?: string | undefined;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    task_summary: string;
+    git_commit: {
+        type: "fix" | "docs" | "test" | "feat" | "style" | "refactor" | "chore";
+        subject: string;
+        scope?: string | undefined;
+        body?: string | undefined;
+        footer?: string | undefined;
+    };
+    spec_changes?: {
+        content: string;
+        action: "REPLACE" | "APPEND";
+        section: string;
+    }[] | undefined;
+    completed_plan_path?: string | undefined;
+}, {
+    task_summary: string;
+    git_commit: {
+        type: "fix" | "docs" | "test" | "feat" | "style" | "refactor" | "chore";
+        subject: string;
+        scope?: string | undefined;
+        body?: string | undefined;
+        footer?: string | undefined;
+    };
+    spec_changes?: {
+        content: string;
+        section: string;
+        action?: "REPLACE" | "APPEND" | undefined;
+    }[] | undefined;
+    completed_plan_path?: string | undefined;
+}>;
+export declare const finalizeWorkOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    updated_files: import("zod").ZodArray<import("zod").ZodString, "many">;
+    commit_hash: import("zod").ZodString;
+    pushed_to_remote: import("zod").ZodBoolean;
+    remote_url: import("zod").ZodOptional<import("zod").ZodString>;
+    warning: import("zod").ZodOptional<import("zod").ZodString>;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.status">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.status";
+        reason: string;
+    }, {
+        tool: "vibe_pm.status";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    next_action: {
+        tool: "vibe_pm.status";
+        reason: string;
+    };
+    updated_files: string[];
+    commit_hash: string;
+    pushed_to_remote: boolean;
+    warning?: string | undefined;
+    remote_url?: string | undefined;
+}, {
+    success: boolean;
+    next_action: {
+        tool: "vibe_pm.status";
+        reason: string;
+    };
+    updated_files: string[];
+    commit_hash: string;
+    pushed_to_remote: boolean;
+    warning?: string | undefined;
+    remote_url?: string | undefined;
+}>;
+export declare const undoLastTaskInputSchema: import("zod").ZodObject<{
+    steps: import("zod").ZodDefault<import("zod").ZodNumber>;
+    reason: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    steps: number;
+    reason?: string | undefined;
+}, {
+    steps?: number | undefined;
+    reason?: string | undefined;
+}>;
+export declare const undoLastTaskOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    reverted_tasks: import("zod").ZodArray<import("zod").ZodObject<{
+        commit_hash: import("zod").ZodString;
+        task_summary: import("zod").ZodString;
+        timestamp: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        timestamp: string;
+        task_summary: string;
+        commit_hash: string;
+    }, {
+        timestamp: string;
+        task_summary: string;
+        commit_hash: string;
+    }>, "many">;
+    current_commit: import("zod").ZodString;
+    message: import("zod").ZodString;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    message: string;
+    reverted_tasks: {
+        timestamp: string;
+        task_summary: string;
+        commit_hash: string;
+    }[];
+    current_commit: string;
+}, {
+    success: boolean;
+    message: string;
+    reverted_tasks: {
+        timestamp: string;
+        task_summary: string;
+        commit_hash: string;
+    }[];
+    current_commit: string;
+}>;
+export declare const runAppInputSchema: import("zod").ZodObject<{
+    mode: import("zod").ZodDefault<import("zod").ZodEnum<["dev", "prod", "test"]>>;
+    port: import("zod").ZodOptional<import("zod").ZodNumber>;
+    container: import("zod").ZodDefault<import("zod").ZodEnum<["none", "podman"]>>;
+    container_image: import("zod").ZodOptional<import("zod").ZodString>;
+    container_ports: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodArray<import("zod").ZodNumber, "many">, number[], number[]>>;
+    container_env: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    container_mounts: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        host: import("zod").ZodString;
+        container: import("zod").ZodString;
+        mode: import("zod").ZodEnum<["ro", "rw"]>;
+    }, "strict", import("zod").ZodTypeAny, {
+        mode: "ro" | "rw";
+        host: string;
+        container: string;
+    }, {
+        mode: "ro" | "rw";
+        host: string;
+        container: string;
+    }>, "many">>;
+    option_key: import("zod").ZodOptional<import("zod").ZodEnum<["A", "B", "C"]>>;
+}, "strict", import("zod").ZodTypeAny, {
+    mode: "test" | "dev" | "prod";
+    container: "none" | "podman";
+    port?: number | undefined;
+    container_image?: string | undefined;
+    container_ports?: number[] | undefined;
+    container_env?: Record<string, string> | undefined;
+    container_mounts?: {
+        mode: "ro" | "rw";
+        host: string;
+        container: string;
+    }[] | undefined;
+    option_key?: "A" | "B" | "C" | undefined;
+}, {
+    mode?: "test" | "dev" | "prod" | undefined;
+    port?: number | undefined;
+    container?: "none" | "podman" | undefined;
+    container_image?: string | undefined;
+    container_ports?: number[] | undefined;
+    container_env?: Record<string, string> | undefined;
+    container_mounts?: {
+        mode: "ro" | "rw";
+        host: string;
+        container: string;
+    }[] | undefined;
+    option_key?: "A" | "B" | "C" | undefined;
+}>;
+export declare const runAppOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    process_id: import("zod").ZodOptional<import("zod").ZodNumber>;
+    url: import("zod").ZodOptional<import("zod").ZodString>;
+    command_executed: import("zod").ZodString;
+    message: import("zod").ZodString;
+    runtime: import("zod").ZodOptional<import("zod").ZodEnum<["host", "podman"]>>;
+    container_id: import("zod").ZodOptional<import("zod").ZodString>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    message: string;
+    command_executed: string;
+    url?: string | undefined;
+    process_id?: number | undefined;
+    runtime?: "podman" | "host" | undefined;
+    container_id?: string | undefined;
+}, {
+    success: boolean;
+    message: string;
+    command_executed: string;
+    url?: string | undefined;
+    process_id?: number | undefined;
+    runtime?: "podman" | "host" | undefined;
+    container_id?: string | undefined;
+}>;
+export declare const exportOutputInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    target: import("zod").ZodEnum<["docs_bundle", "api_openapi", "cli_scaffold", "web_template_repo"]>;
+    output_dir: import("zod").ZodOptional<import("zod").ZodString>;
+    dry_run: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    cli_language: import("zod").ZodDefault<import("zod").ZodEnum<["python", "node"]>>;
+    template_pin: import("zod").ZodOptional<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        ref: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        repo: string;
+        ref: string;
+    }, {
+        repo: string;
+        ref: string;
+    }>>;
+}, "strict", import("zod").ZodTypeAny, {
+    target: "docs_bundle" | "api_openapi" | "cli_scaffold" | "web_template_repo";
+    dry_run: boolean;
+    cli_language: "node" | "python";
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    output_dir?: string | undefined;
+    template_pin?: {
+        repo: string;
+        ref: string;
+    } | undefined;
+}, {
+    target: "docs_bundle" | "api_openapi" | "cli_scaffold" | "web_template_repo";
+    run_id?: string | undefined;
+    dry_run?: boolean | undefined;
+    project_id?: string | undefined;
+    output_dir?: string | undefined;
+    cli_language?: "node" | "python" | undefined;
+    template_pin?: {
+        repo: string;
+        ref: string;
+    } | undefined;
+}>;
+export declare const exportOutputOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    target: import("zod").ZodString;
+    output_dir: import("zod").ZodString;
+    dry_run: import("zod").ZodBoolean;
+    paths: import("zod").ZodObject<{
+        feature_output_spec_path: import("zod").ZodString;
+        export_plan_path: import("zod").ZodString;
+        export_artifacts_path: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        feature_output_spec_path: string;
+        export_plan_path: string;
+        export_artifacts_path?: string | undefined;
+    }, {
+        feature_output_spec_path: string;
+        export_plan_path: string;
+        export_artifacts_path?: string | undefined;
+    }>;
+    created_paths: import("zod").ZodArray<import("zod").ZodString, "many">;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.status">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.status";
+        reason: string;
+    }, {
+        tool: "vibe_pm.status";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    target: string;
+    success: boolean;
+    run_id: string;
+    dry_run: boolean;
+    paths: {
+        feature_output_spec_path: string;
+        export_plan_path: string;
+        export_artifacts_path?: string | undefined;
+    };
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.status";
+        reason: string;
+    };
+    warnings: string[];
+    created_paths: string[];
+    output_dir: string;
+}, {
+    target: string;
+    success: boolean;
+    run_id: string;
+    dry_run: boolean;
+    paths: {
+        feature_output_spec_path: string;
+        export_plan_path: string;
+        export_artifacts_path?: string | undefined;
+    };
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.status";
+        reason: string;
+    };
+    warnings: string[];
+    created_paths: string[];
+    output_dir: string;
+}>;
+export declare const searchOssInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    intent: import("zod").ZodString;
+    keywords: import("zod").ZodArray<import("zod").ZodString, "many">;
+    constraints: import("zod").ZodOptional<import("zod").ZodObject<{
+        license_allowlist: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        min_stars: import("zod").ZodOptional<import("zod").ZodNumber>;
+        updated_within_days: import("zod").ZodOptional<import("zod").ZodNumber>;
+        language: import("zod").ZodOptional<import("zod").ZodString>;
+        limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        sort: import("zod").ZodDefault<import("zod").ZodEnum<["stars", "updated", "best-match"]>>;
+    }, "strict", import("zod").ZodTypeAny, {
+        sort: "updated" | "stars" | "best-match";
+        limit: number;
+        license_allowlist?: string[] | undefined;
+        min_stars?: number | undefined;
+        updated_within_days?: number | undefined;
+        language?: string | undefined;
+    }, {
+        sort?: "updated" | "stars" | "best-match" | undefined;
+        limit?: number | undefined;
+        license_allowlist?: string[] | undefined;
+        min_stars?: number | undefined;
+        updated_within_days?: number | undefined;
+        language?: string | undefined;
+    }>>;
+    write_evidence: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    intent: string;
+    keywords: string[];
+    write_evidence: boolean;
+    run_id?: string | undefined;
+    constraints?: {
+        sort: "updated" | "stars" | "best-match";
+        limit: number;
+        license_allowlist?: string[] | undefined;
+        min_stars?: number | undefined;
+        updated_within_days?: number | undefined;
+        language?: string | undefined;
+    } | undefined;
+}, {
+    project_id: string;
+    intent: string;
+    keywords: string[];
+    run_id?: string | undefined;
+    constraints?: {
+        sort?: "updated" | "stars" | "best-match" | undefined;
+        limit?: number | undefined;
+        license_allowlist?: string[] | undefined;
+        min_stars?: number | undefined;
+        updated_within_days?: number | undefined;
+        language?: string | undefined;
+    } | undefined;
+    write_evidence?: boolean | undefined;
+}>;
+export declare const searchOssOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    intent: import("zod").ZodString;
+    query: import("zod").ZodString;
+    evidence_path: import("zod").ZodOptional<import("zod").ZodString>;
+    candidates: import("zod").ZodArray<import("zod").ZodObject<{
+        repo: import("zod").ZodString;
+        url: import("zod").ZodString;
+        description: import("zod").ZodString;
+        license: import("zod").ZodString;
+        stars: import("zod").ZodNumber;
+        updated_at: import("zod").ZodString;
+        ref_candidates: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        url: string;
+        updated_at: string;
+        description: string;
+        repo: string;
+        stars: number;
+        license: string;
+        ref_candidates: string[];
+    }, {
+        url: string;
+        updated_at: string;
+        description: string;
+        repo: string;
+        stars: number;
+        license: string;
+        ref_candidates: string[];
+    }>, "many">;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.export_output">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    }, {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    intent: string;
+    next_action: {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    };
+    warnings: string[];
+    query: string;
+    candidates: {
+        url: string;
+        updated_at: string;
+        description: string;
+        repo: string;
+        stars: number;
+        license: string;
+        ref_candidates: string[];
+    }[];
+    evidence_path?: string | undefined;
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    intent: string;
+    next_action: {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    };
+    warnings: string[];
+    query: string;
+    candidates: {
+        url: string;
+        updated_at: string;
+        description: string;
+        repo: string;
+        stars: number;
+        license: string;
+        ref_candidates: string[];
+    }[];
+    evidence_path?: string | undefined;
+}>;
+export declare const zoektEvidenceInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    roots: import("zod").ZodArray<import("zod").ZodString, "many">;
+    queries: import("zod").ZodArray<import("zod").ZodString, "many">;
+    sample_paths: import("zod").ZodDefault<import("zod").ZodNumber>;
+    max_file_bytes: import("zod").ZodDefault<import("zod").ZodNumber>;
+    write_evidence: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    sample_paths: number;
+    write_evidence: boolean;
+    roots: string[];
+    queries: string[];
+    max_file_bytes: number;
+    run_id?: string | undefined;
+}, {
+    project_id: string;
+    roots: string[];
+    queries: string[];
+    run_id?: string | undefined;
+    sample_paths?: number | undefined;
+    write_evidence?: boolean | undefined;
+    max_file_bytes?: number | undefined;
+}>;
+export declare const zoektEvidenceOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    engine: import("zod").ZodEnum<["zoekt", "rg", "python_scan"]>;
+    evidence_path: import("zod").ZodOptional<import("zod").ZodString>;
+    queries: import("zod").ZodArray<import("zod").ZodObject<{
+        q: import("zod").ZodString;
+        repos_scanned: import("zod").ZodNumber;
+        match_count: import("zod").ZodNumber;
+        sample_paths: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        sample_paths: string[];
+        q: string;
+        repos_scanned: number;
+        match_count: number;
+    }, {
+        sample_paths: string[];
+        q: string;
+        repos_scanned: number;
+        match_count: number;
+    }>, "many">;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.export_output">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    }, {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    engine: "zoekt" | "rg" | "python_scan";
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    };
+    warnings: string[];
+    queries: {
+        sample_paths: string[];
+        q: string;
+        repos_scanned: number;
+        match_count: number;
+    }[];
+    evidence_path?: string | undefined;
+}, {
+    engine: "zoekt" | "rg" | "python_scan";
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.export_output";
+        reason: string;
+    };
+    warnings: string[];
+    queries: {
+        sample_paths: string[];
+        q: string;
+        repos_scanned: number;
+        match_count: number;
+    }[];
+    evidence_path?: string | undefined;
+}>;
+export declare const readFileInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    path: import("zod").ZodString;
+    max_file_bytes: import("zod").ZodDefault<import("zod").ZodNumber>;
+    max_symbols: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, "strict", import("zod").ZodTypeAny, {
+    path: string;
+    project_id: string;
+    max_file_bytes: number;
+    max_symbols: number;
+    run_id?: string | undefined;
+}, {
+    path: string;
+    project_id: string;
+    run_id?: string | undefined;
+    max_file_bytes?: number | undefined;
+    max_symbols?: number | undefined;
+}>;
+export declare const readFileOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    file: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        zone: import("zod").ZodEnum<["GREEN", "YELLOW", "RED", "BLACK", "UNKNOWN"]>;
+        bytes: import("zod").ZodNumber;
+        mtime: import("zod").ZodString;
+        language: import("zod").ZodEnum<["ts", "js", "py", "rs", "json", "md", "unknown"]>;
+        analysis_status: import("zod").ZodEnum<["OK", "FAILED"]>;
+        symbols: import("zod").ZodArray<import("zod").ZodObject<{
+            kind: import("zod").ZodEnum<["function", "class", "const", "type", "trait", "module", "other"]>;
+            name: import("zod").ZodString;
+            signature: import("zod").ZodString;
+            line: import("zod").ZodNumber;
+        }, "strict", import("zod").ZodTypeAny, {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }, {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }>, "many">;
+        notes: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+        analysis_status: "OK" | "FAILED";
+        symbols: {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }[];
+        notes: string[];
+    }, {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+        analysis_status: "OK" | "FAILED";
+        symbols: {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }[];
+        notes: string[];
+    }>;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.create_work_order", "vibe_pm.repair_analysis_engine"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    }, {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    };
+    file: {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+        analysis_status: "OK" | "FAILED";
+        symbols: {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }[];
+        notes: string[];
+    };
+    warnings: string[];
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    };
+    file: {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+        analysis_status: "OK" | "FAILED";
+        symbols: {
+            signature: string;
+            name: string;
+            line: number;
+            kind: "function" | "type" | "other" | "class" | "const" | "trait" | "module";
+        }[];
+        notes: string[];
+    };
+    warnings: string[];
+}>;
+export declare const getSemanticComplexityInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    path: import("zod").ZodString;
+    max_file_bytes: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+    max_functions: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+}, "strict", import("zod").ZodTypeAny, {
+    path: string;
+    project_id: string;
+    max_file_bytes: number;
+    max_functions: number;
+    run_id?: string | undefined;
+}, {
+    path: string;
+    project_id: string;
+    run_id?: string | undefined;
+    max_file_bytes?: number | undefined;
+    max_functions?: number | undefined;
+}>;
+export declare const getSemanticComplexityOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    analysis_status: import("zod").ZodEnum<["OK", "FAILED"]>;
+    file: import("zod").ZodObject<{
+        path: import("zod").ZodString;
+        zone: import("zod").ZodEnum<["GREEN", "YELLOW", "RED", "BLACK", "UNKNOWN"]>;
+        bytes: import("zod").ZodNumber;
+        mtime: import("zod").ZodString;
+        language: import("zod").ZodEnum<["ts", "js", "py", "rs", "json", "md", "unknown"]>;
+    }, "strict", import("zod").ZodTypeAny, {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+    }, {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+    }>;
+    file_metrics: import("zod").ZodObject<{
+        imports_count: import("zod").ZodNumber;
+        exports_count: import("zod").ZodNumber;
+        imported_by_count: import("zod").ZodNumber;
+        blast_radius_index: import("zod").ZodNumber;
+        technical_debt_ratio: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        imports_count: number;
+        exports_count: number;
+        imported_by_count: number;
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+    }, {
+        imports_count: number;
+        exports_count: number;
+        imported_by_count: number;
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+    }>;
+    functions: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        kind: import("zod").ZodEnum<["function", "method", "closure", "other"]>;
+        start_line: import("zod").ZodNumber;
+        end_line: import("zod").ZodNumber;
+        cyclomatic_complexity: import("zod").ZodNumber;
+        cognitive_load_score: import("zod").ZodEnum<["LOW", "MEDIUM", "HIGH"]>;
+        technical_debt_ratio: import("zod").ZodNumber;
+        blast_radius_index: import("zod").ZodNumber;
+        exported: import("zod").ZodBoolean;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        kind: "function" | "method" | "other" | "closure";
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+        start_line: number;
+        end_line: number;
+        cyclomatic_complexity: number;
+        cognitive_load_score: "HIGH" | "MEDIUM" | "LOW";
+        exported: boolean;
+    }, {
+        name: string;
+        kind: "function" | "method" | "other" | "closure";
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+        start_line: number;
+        end_line: number;
+        cyclomatic_complexity: number;
+        cognitive_load_score: "HIGH" | "MEDIUM" | "LOW";
+        exported: boolean;
+    }>, "many">;
+    enforced_constraints: import("zod").ZodArray<import("zod").ZodString, "many">;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.advisory_review", "vibe_pm.create_work_order", "vibe_pm.repair_analysis_engine"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.advisory_review" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    }, {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.advisory_review" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.advisory_review" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    };
+    file: {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+    };
+    warnings: string[];
+    analysis_status: "OK" | "FAILED";
+    file_metrics: {
+        imports_count: number;
+        exports_count: number;
+        imported_by_count: number;
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+    };
+    functions: {
+        name: string;
+        kind: "function" | "method" | "other" | "closure";
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+        start_line: number;
+        end_line: number;
+        cyclomatic_complexity: number;
+        cognitive_load_score: "HIGH" | "MEDIUM" | "LOW";
+        exported: boolean;
+    }[];
+    enforced_constraints: string[];
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order" | "vibe_pm.advisory_review" | "vibe_pm.repair_analysis_engine";
+        reason: string;
+    };
+    file: {
+        path: string;
+        bytes: number;
+        mtime: string;
+        language: "unknown" | "json" | "ts" | "js" | "py" | "rs" | "md";
+        zone: "BLACK" | "RED" | "YELLOW" | "UNKNOWN" | "GREEN";
+    };
+    warnings: string[];
+    analysis_status: "OK" | "FAILED";
+    file_metrics: {
+        imports_count: number;
+        exports_count: number;
+        imported_by_count: number;
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+    };
+    functions: {
+        name: string;
+        kind: "function" | "method" | "other" | "closure";
+        blast_radius_index: number;
+        technical_debt_ratio: number;
+        start_line: number;
+        end_line: number;
+        cyclomatic_complexity: number;
+        cognitive_load_score: "HIGH" | "MEDIUM" | "LOW";
+        exported: boolean;
+    }[];
+    enforced_constraints: string[];
+}>;
+export declare const repairAnalysisEngineInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    target_file: import("zod").ZodString;
+    error_context: import("zod").ZodString;
+    fix_action: import("zod").ZodEnum<["RETRY", "FIX_ENCODING", "FIX_SYNTAX_ERROR", "UPDATE_DEPENDENCY", "REGENERATE_CONTRACTS"]>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    target_file: string;
+    error_context: string;
+    fix_action: "RETRY" | "FIX_ENCODING" | "FIX_SYNTAX_ERROR" | "UPDATE_DEPENDENCY" | "REGENERATE_CONTRACTS";
+    run_id?: string | undefined;
+}, {
+    project_id: string;
+    target_file: string;
+    error_context: string;
+    fix_action: "RETRY" | "FIX_ENCODING" | "FIX_SYNTAX_ERROR" | "UPDATE_DEPENDENCY" | "REGENERATE_CONTRACTS";
+    run_id?: string | undefined;
+}>;
+export declare const repairAnalysisEngineOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    status: import("zod").ZodEnum<["RECOVERED", "NOT_RECOVERED"]>;
+    message: import("zod").ZodString;
+    actions_taken: import("zod").ZodArray<import("zod").ZodString, "many">;
+    details: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.read_file", "vibe_pm.doctor"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.doctor" | "vibe_pm.read_file";
+        reason: string;
+    }, {
+        tool: "vibe_pm.doctor" | "vibe_pm.read_file";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    status: "RECOVERED" | "NOT_RECOVERED";
+    run_id: string;
+    message: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.doctor" | "vibe_pm.read_file";
+        reason: string;
+    };
+    actions_taken: string[];
+    details?: Record<string, any> | undefined;
+}, {
+    success: boolean;
+    status: "RECOVERED" | "NOT_RECOVERED";
+    run_id: string;
+    message: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.doctor" | "vibe_pm.read_file";
+        reason: string;
+    };
+    actions_taken: string[];
+    details?: Record<string, any> | undefined;
+}>;
+export declare const ingressInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    workspace_path: import("zod").ZodOptional<import("zod").ZodString>;
+    resolution: import("zod").ZodOptional<import("zod").ZodEnum<["INGRESS_RESOLVED_RESUME", "INGRESS_RESOLVED_NEW_TASK", "INGRESS_RESOLVED_ADOPT", "INGRESS_ABORTED"]>>;
+    auto_resolve: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    force: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    context_scan: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    write_files: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    force: boolean;
+    auto_resolve: boolean;
+    context_scan: boolean;
+    write_files: boolean;
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    resolution?: "INGRESS_RESOLVED_RESUME" | "INGRESS_RESOLVED_NEW_TASK" | "INGRESS_RESOLVED_ADOPT" | "INGRESS_ABORTED" | undefined;
+    workspace_path?: string | undefined;
+}, {
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    resolution?: "INGRESS_RESOLVED_RESUME" | "INGRESS_RESOLVED_NEW_TASK" | "INGRESS_RESOLVED_ADOPT" | "INGRESS_ABORTED" | undefined;
+    force?: boolean | undefined;
+    workspace_path?: string | undefined;
+    auto_resolve?: boolean | undefined;
+    context_scan?: boolean | undefined;
+    write_files?: boolean | undefined;
+}>;
+export declare const ingressOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    workspace_path: import("zod").ZodString;
+    has_vibe_state: import("zod").ZodBoolean;
+    resolution: import("zod").ZodEnum<["INGRESS_RESOLVED_RESUME", "INGRESS_RESOLVED_NEW_TASK", "INGRESS_RESOLVED_ADOPT", "INGRESS_ABORTED"]>;
+    auto_resolve_reason: import("zod").ZodOptional<import("zod").ZodString>;
+    context_scan_required: import("zod").ZodBoolean;
+    context_scan_completed: import("zod").ZodBoolean;
+    ingress_resolution_path: import("zod").ZodString;
+    artifacts: import("zod").ZodOptional<import("zod").ZodObject<{
+        project_fingerprint: import("zod").ZodOptional<import("zod").ZodString>;
+        repo_map: import("zod").ZodOptional<import("zod").ZodString>;
+        entrypoints: import("zod").ZodOptional<import("zod").ZodString>;
+        docs_index: import("zod").ZodOptional<import("zod").ZodString>;
+        risk_flags: import("zod").ZodOptional<import("zod").ZodString>;
+        ingress_summary: import("zod").ZodOptional<import("zod").ZodString>;
+        change_map: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        change_map?: string | undefined;
+        ingress_summary?: string | undefined;
+        project_fingerprint?: string | undefined;
+        risk_flags?: string | undefined;
+        repo_map?: string | undefined;
+        entrypoints?: string | undefined;
+        docs_index?: string | undefined;
+    }, {
+        change_map?: string | undefined;
+        ingress_summary?: string | undefined;
+        project_fingerprint?: string | undefined;
+        risk_flags?: string | undefined;
+        repo_map?: string | undefined;
+        entrypoints?: string | undefined;
+        docs_index?: string | undefined;
+    }>>;
+    mapping: import("zod").ZodOptional<import("zod").ZodObject<{
+        change_map_path: import("zod").ZodString;
+        mapped_count: import("zod").ZodNumber;
+        unmapped_count: import("zod").ZodNumber;
+        domains_touched: import("zod").ZodArray<import("zod").ZodString, "many">;
+        verdict: import("zod").ZodEnum<["GO", "FIX", "BLOCK"]>;
+    }, "strict", import("zod").ZodTypeAny, {
+        verdict: "GO" | "FIX" | "BLOCK";
+        change_map_path: string;
+        mapped_count: number;
+        unmapped_count: number;
+        domains_touched: string[];
+    }, {
+        verdict: "GO" | "FIX" | "BLOCK";
+        change_map_path: string;
+        mapped_count: number;
+        unmapped_count: number;
+        domains_touched: string[];
+    }>>;
+    warnings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    message: import("zod").ZodString;
+    next_action: import("zod").ZodUnion<[import("zod").ZodObject<{
+        tool: import("zod").ZodEnum<["vibe_pm.get_decision", "vibe_pm.briefing", "vibe_pm.ingress"]>;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.briefing" | "vibe_pm.get_decision" | "vibe_pm.ingress";
+        reason: string;
+    }, {
+        tool: "vibe_pm.briefing" | "vibe_pm.get_decision" | "vibe_pm.ingress";
+        reason: string;
+    }>, import("zod").ZodNull]>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    message: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.briefing" | "vibe_pm.get_decision" | "vibe_pm.ingress";
+        reason: string;
+    } | null;
+    resolution: "INGRESS_RESOLVED_RESUME" | "INGRESS_RESOLVED_NEW_TASK" | "INGRESS_RESOLVED_ADOPT" | "INGRESS_ABORTED";
+    workspace_path: string;
+    has_vibe_state: boolean;
+    context_scan_required: boolean;
+    context_scan_completed: boolean;
+    ingress_resolution_path: string;
+    artifacts?: {
+        change_map?: string | undefined;
+        ingress_summary?: string | undefined;
+        project_fingerprint?: string | undefined;
+        risk_flags?: string | undefined;
+        repo_map?: string | undefined;
+        entrypoints?: string | undefined;
+        docs_index?: string | undefined;
+    } | undefined;
+    mapping?: {
+        verdict: "GO" | "FIX" | "BLOCK";
+        change_map_path: string;
+        mapped_count: number;
+        unmapped_count: number;
+        domains_touched: string[];
+    } | undefined;
+    warnings?: string[] | undefined;
+    auto_resolve_reason?: string | undefined;
+}, {
+    success: boolean;
+    run_id: string;
+    message: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.briefing" | "vibe_pm.get_decision" | "vibe_pm.ingress";
+        reason: string;
+    } | null;
+    resolution: "INGRESS_RESOLVED_RESUME" | "INGRESS_RESOLVED_NEW_TASK" | "INGRESS_RESOLVED_ADOPT" | "INGRESS_ABORTED";
+    workspace_path: string;
+    has_vibe_state: boolean;
+    context_scan_required: boolean;
+    context_scan_completed: boolean;
+    ingress_resolution_path: string;
+    artifacts?: {
+        change_map?: string | undefined;
+        ingress_summary?: string | undefined;
+        project_fingerprint?: string | undefined;
+        risk_flags?: string | undefined;
+        repo_map?: string | undefined;
+        entrypoints?: string | undefined;
+        docs_index?: string | undefined;
+    } | undefined;
+    mapping?: {
+        verdict: "GO" | "FIX" | "BLOCK";
+        change_map_path: string;
+        mapped_count: number;
+        unmapped_count: number;
+        domains_touched: string[];
+    } | undefined;
+    warnings?: string[] | undefined;
+    auto_resolve_reason?: string | undefined;
+}>;
+export declare const bridgeGenerateReferencesInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    raw_user_intent: import("zod").ZodString;
+    keywords: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    constraints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    must_have: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    must_not: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    candidates_seed: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        title: import("zod").ZodString;
+        kind: import("zod").ZodEnum<["oss_repo", "library", "product", "pattern", "doc"]>;
+        primary_link: import("zod").ZodString;
+        why_similar: import("zod").ZodOptional<import("zod").ZodString>;
+        fit_summary: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        title: string;
+        kind: "doc" | "pattern" | "oss_repo" | "library" | "product";
+        primary_link: string;
+        why_similar?: string | undefined;
+        fit_summary?: string | undefined;
+    }, {
+        title: string;
+        kind: "doc" | "pattern" | "oss_repo" | "library" | "product";
+        primary_link: string;
+        why_similar?: string | undefined;
+        fit_summary?: string | undefined;
+    }>, "many">>;
+    max_candidates: import("zod").ZodDefault<import("zod").ZodNumber>;
+    write_files: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    write_files: boolean;
+    raw_user_intent: string;
+    max_candidates: number;
+    run_id?: string | undefined;
+    keywords?: string[] | undefined;
+    constraints?: string[] | undefined;
+    must_have?: string[] | undefined;
+    must_not?: string[] | undefined;
+    candidates_seed?: {
+        title: string;
+        kind: "doc" | "pattern" | "oss_repo" | "library" | "product";
+        primary_link: string;
+        why_similar?: string | undefined;
+        fit_summary?: string | undefined;
+    }[] | undefined;
+}, {
+    project_id: string;
+    raw_user_intent: string;
+    run_id?: string | undefined;
+    keywords?: string[] | undefined;
+    constraints?: string[] | undefined;
+    write_files?: boolean | undefined;
+    must_have?: string[] | undefined;
+    must_not?: string[] | undefined;
+    candidates_seed?: {
+        title: string;
+        kind: "doc" | "pattern" | "oss_repo" | "library" | "product";
+        primary_link: string;
+        why_similar?: string | undefined;
+        fit_summary?: string | undefined;
+    }[] | undefined;
+    max_candidates?: number | undefined;
+}>;
+export declare const bridgeGenerateReferencesOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    references_path: import("zod").ZodString;
+    candidates: import("zod").ZodArray<import("zod").ZodObject<{
+        key: import("zod").ZodEnum<["A", "B", "C"]>;
+        title: import("zod").ZodString;
+        primary_link: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }, {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }>, "many">;
+    warnings: import("zod").ZodArray<import("zod").ZodString, "many">;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.bridge_confirm_reference">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.bridge_confirm_reference";
+        reason: string;
+    }, {
+        tool: "vibe_pm.bridge_confirm_reference";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.bridge_confirm_reference";
+        reason: string;
+    };
+    warnings: string[];
+    candidates: {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }[];
+    references_path: string;
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.bridge_confirm_reference";
+        reason: string;
+    };
+    warnings: string[];
+    candidates: {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }[];
+    references_path: string;
+}>;
+export declare const bridgeConfirmReferenceInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    selected_key: import("zod").ZodEnum<["A", "B", "C"]>;
+    raw_answer: import("zod").ZodString;
+    notes: import("zod").ZodOptional<import("zod").ZodString>;
+    must_have_overrides: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    must_not_overrides: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    write_files: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    write_files: boolean;
+    selected_key: "A" | "B" | "C";
+    raw_answer: string;
+    run_id?: string | undefined;
+    notes?: string | undefined;
+    must_have_overrides?: string[] | undefined;
+    must_not_overrides?: string[] | undefined;
+}, {
+    project_id: string;
+    selected_key: "A" | "B" | "C";
+    raw_answer: string;
+    run_id?: string | undefined;
+    notes?: string | undefined;
+    write_files?: boolean | undefined;
+    must_have_overrides?: string[] | undefined;
+    must_not_overrides?: string[] | undefined;
+}>;
+export declare const bridgeConfirmReferenceOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    confirmed_reference_path: import("zod").ZodString;
+    selected: import("zod").ZodObject<{
+        key: import("zod").ZodEnum<["A", "B", "C"]>;
+        title: import("zod").ZodString;
+        primary_link: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }, {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    }>;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.bridge_build_seed">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.bridge_build_seed";
+        reason: string;
+    }, {
+        tool: "vibe_pm.bridge_build_seed";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.bridge_build_seed";
+        reason: string;
+    };
+    confirmed_reference_path: string;
+    selected: {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    };
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.bridge_build_seed";
+        reason: string;
+    };
+    confirmed_reference_path: string;
+    selected: {
+        key: "A" | "B" | "C";
+        title: string;
+        primary_link: string;
+    };
+}>;
+export declare const bridgeBuildSeedInputSchema: import("zod").ZodObject<{
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    raw_user_intent: import("zod").ZodOptional<import("zod").ZodString>;
+    goal: import("zod").ZodOptional<import("zod").ZodString>;
+    user_story: import("zod").ZodOptional<import("zod").ZodString>;
+    acceptance: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    constraints: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    non_goals: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    scope_seed: import("zod").ZodOptional<import("zod").ZodObject<{
+        include: import("zod").ZodArray<import("zod").ZodString, "many">;
+        exclude: import("zod").ZodArray<import("zod").ZodString, "many">;
+        do_not_touch: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    }, "strict", import("zod").ZodTypeAny, {
+        include: string[];
+        exclude: string[];
+        do_not_touch?: string[] | undefined;
+    }, {
+        include: string[];
+        exclude: string[];
+        do_not_touch?: string[] | undefined;
+    }>>;
+    preferred_stack_hint: import("zod").ZodOptional<import("zod").ZodString>;
+    risk_notes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    overwrite: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    write_files: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, "strict", import("zod").ZodTypeAny, {
+    project_id: string;
+    write_files: boolean;
+    overwrite: boolean;
+    run_id?: string | undefined;
+    goal?: string | undefined;
+    risk_notes?: string[] | undefined;
+    constraints?: string[] | undefined;
+    raw_user_intent?: string | undefined;
+    user_story?: string | undefined;
+    acceptance?: string[] | undefined;
+    non_goals?: string[] | undefined;
+    scope_seed?: {
+        include: string[];
+        exclude: string[];
+        do_not_touch?: string[] | undefined;
+    } | undefined;
+    preferred_stack_hint?: string | undefined;
+}, {
+    project_id: string;
+    run_id?: string | undefined;
+    goal?: string | undefined;
+    risk_notes?: string[] | undefined;
+    constraints?: string[] | undefined;
+    write_files?: boolean | undefined;
+    raw_user_intent?: string | undefined;
+    user_story?: string | undefined;
+    acceptance?: string[] | undefined;
+    non_goals?: string[] | undefined;
+    scope_seed?: {
+        include: string[];
+        exclude: string[];
+        do_not_touch?: string[] | undefined;
+    } | undefined;
+    preferred_stack_hint?: string | undefined;
+    overwrite?: boolean | undefined;
+}>;
+export declare const bridgeBuildSeedOutputSchema: import("zod").ZodObject<{
+    success: import("zod").ZodBoolean;
+    project_id: import("zod").ZodString;
+    run_id: import("zod").ZodString;
+    seed_path: import("zod").ZodString;
+    next_action: import("zod").ZodObject<{
+        tool: import("zod").ZodLiteral<"vibe_pm.create_work_order">;
+        reason: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        tool: "vibe_pm.create_work_order";
+        reason: string;
+    }, {
+        tool: "vibe_pm.create_work_order";
+        reason: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order";
+        reason: string;
+    };
+    seed_path: string;
+}, {
+    success: boolean;
+    run_id: string;
+    project_id: string;
+    next_action: {
+        tool: "vibe_pm.create_work_order";
+        reason: string;
+    };
+    seed_path: string;
+}>;
+export declare const doctorOutputSchema: import("zod").ZodObject<{
+    status: import("zod").ZodEnum<["OK", "FIXED", "NEEDS_ATTENTION", "ERROR"]>;
+    summary: import("zod").ZodString;
+    contracts: import("zod").ZodOptional<import("zod").ZodObject<{
+        version: import("zod").ZodString;
+        bundle_sha256: import("zod").ZodString;
+        schema_count: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        version: string;
+        bundle_sha256: string;
+        schema_count: number;
+    }, {
+        version: string;
+        bundle_sha256: string;
+        schema_count: number;
+    }>>;
+    engines: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        status: import("zod").ZodEnum<["정상", "업데이트 필요", "설치 필요", "손상됨"]>;
+        version: import("zod").ZodString;
+        current_version: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+    }, "strict", import("zod").ZodTypeAny, {
+        version: string;
+        status: "설치 필요" | "업데이트 필요" | "정상" | "손상됨";
+        name: string;
+        current_version: string | null;
+    }, {
+        version: string;
+        status: "설치 필요" | "업데이트 필요" | "정상" | "손상됨";
+        name: string;
+        current_version: string | null;
+    }>, "many">;
+    actions_taken: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    python_cli: import("zod").ZodOptional<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<["정상", "오류"]>;
+        message: import("zod").ZodString;
+        pythonpath_detected: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "정상" | "오류";
+        message: string;
+        pythonpath_detected: string | null;
+    }, {
+        status: "정상" | "오류";
+        message: string;
+        pythonpath_detected: string | null;
+    }>>;
+    claude_hook: import("zod").ZodOptional<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<["정상", "설치 필요", "설정 필요"]>;
+        hook_script_exists: import("zod").ZodBoolean;
+        settings_json_exists: import("zod").ZodBoolean;
+        is_executable: import("zod").ZodBoolean;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "설치 필요" | "정상" | "설정 필요";
+        hook_script_exists: boolean;
+        settings_json_exists: boolean;
+        is_executable: boolean;
+    }, {
+        status: "설치 필요" | "정상" | "설정 필요";
+        hook_script_exists: boolean;
+        settings_json_exists: boolean;
+        is_executable: boolean;
+    }>>;
+    skills: import("zod").ZodOptional<import("zod").ZodObject<{
+        status: import("zod").ZodEnum<["OK", "WARN", "ERROR"]>;
+        version: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+        installed: import("zod").ZodNumber;
+        total: import("zod").ZodNumber;
+    }, "strict", import("zod").ZodTypeAny, {
+        version: string | null;
+        status: "WARN" | "ERROR" | "OK";
+        total: number;
+        installed: number;
+    }, {
+        version: string | null;
+        status: "WARN" | "ERROR" | "OK";
+        total: number;
+        installed: number;
+    }>>;
+    remote_updates: import("zod").ZodOptional<import("zod").ZodObject<{
+        available: import("zod").ZodBoolean;
+        release_tag: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+        updates: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            current: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+            remote: import("zod").ZodString;
+        }, "strict", import("zod").ZodTypeAny, {
+            name: string;
+            current: string | null;
+            remote: string;
+        }, {
+            name: string;
+            current: string | null;
+            remote: string;
+        }>, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        available: boolean;
+        release_tag: string | null;
+        updates: {
+            name: string;
+            current: string | null;
+            remote: string;
+        }[];
+    }, {
+        available: boolean;
+        release_tag: string | null;
+        updates: {
+            name: string;
+            current: string | null;
+            remote: string;
+        }[];
+    }>>;
+    local_memory: import("zod").ZodOptional<import("zod").ZodEffects<import("zod").ZodAny, any, any>>;
+    next_action: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<["NONE", "MANUAL_FIX", "CONTACT_SUPPORT"]>;
+        message: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        type: "NONE" | "MANUAL_FIX" | "CONTACT_SUPPORT";
+        message: string;
+    }, {
+        type: "NONE" | "MANUAL_FIX" | "CONTACT_SUPPORT";
+        message: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    engines: {
+        version: string;
+        status: "설치 필요" | "업데이트 필요" | "정상" | "손상됨";
+        name: string;
+        current_version: string | null;
+    }[];
+    status: "ERROR" | "OK" | "FIXED" | "NEEDS_ATTENTION";
+    next_action: {
+        type: "NONE" | "MANUAL_FIX" | "CONTACT_SUPPORT";
+        message: string;
+    };
+    summary: string;
+    skills?: {
+        version: string | null;
+        status: "WARN" | "ERROR" | "OK";
+        total: number;
+        installed: number;
+    } | undefined;
+    contracts?: {
+        version: string;
+        bundle_sha256: string;
+        schema_count: number;
+    } | undefined;
+    actions_taken?: string[] | undefined;
+    python_cli?: {
+        status: "정상" | "오류";
+        message: string;
+        pythonpath_detected: string | null;
+    } | undefined;
+    claude_hook?: {
+        status: "설치 필요" | "정상" | "설정 필요";
+        hook_script_exists: boolean;
+        settings_json_exists: boolean;
+        is_executable: boolean;
+    } | undefined;
+    remote_updates?: {
+        available: boolean;
+        release_tag: string | null;
+        updates: {
+            name: string;
+            current: string | null;
+            remote: string;
+        }[];
+    } | undefined;
+    local_memory?: any;
+}, {
+    engines: {
+        version: string;
+        status: "설치 필요" | "업데이트 필요" | "정상" | "손상됨";
+        name: string;
+        current_version: string | null;
+    }[];
+    status: "ERROR" | "OK" | "FIXED" | "NEEDS_ATTENTION";
+    next_action: {
+        type: "NONE" | "MANUAL_FIX" | "CONTACT_SUPPORT";
+        message: string;
+    };
+    summary: string;
+    skills?: {
+        version: string | null;
+        status: "WARN" | "ERROR" | "OK";
+        total: number;
+        installed: number;
+    } | undefined;
+    contracts?: {
+        version: string;
+        bundle_sha256: string;
+        schema_count: number;
+    } | undefined;
+    actions_taken?: string[] | undefined;
+    python_cli?: {
+        status: "정상" | "오류";
+        message: string;
+        pythonpath_detected: string | null;
+    } | undefined;
+    claude_hook?: {
+        status: "설치 필요" | "정상" | "설정 필요";
+        hook_script_exists: boolean;
+        settings_json_exists: boolean;
+        is_executable: boolean;
+    } | undefined;
+    remote_updates?: {
+        available: boolean;
+        release_tag: string | null;
+        updates: {
+            name: string;
+            current: string | null;
+            remote: string;
+        }[];
+    } | undefined;
+    local_memory?: any;
+}>;
+export declare const updateOutputSchema: import("zod").ZodObject<{
+    status: import("zod").ZodEnum<["OK", "PARTIAL", "ERROR"]>;
+    summary: import("zod").ZodString;
+    results: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        action: import("zod").ZodEnum<["updated", "skipped", "failed"]>;
+        from_version: import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>;
+        to_version: import("zod").ZodString;
+        message: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        name: string;
+        message: string;
+        from_version: string | null;
+        to_version: string;
+        action: "failed" | "skipped" | "updated";
+    }, {
+        name: string;
+        message: string;
+        from_version: string | null;
+        to_version: string;
+        action: "failed" | "skipped" | "updated";
+    }>, "many">>;
+    npm_result: import("zod").ZodOptional<import("zod").ZodObject<{
+        action: import("zod").ZodEnum<["updated", "skipped", "failed"]>;
+        from_version: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+        to_version: import("zod").ZodOptional<import("zod").ZodUnion<[import("zod").ZodString, import("zod").ZodNull]>>;
+        message: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        from_version?: string | null | undefined;
+        to_version?: string | null | undefined;
+    }, {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        from_version?: string | null | undefined;
+        to_version?: string | null | undefined;
+    }>>;
+    local_result: import("zod").ZodOptional<import("zod").ZodObject<{
+        action: import("zod").ZodEnum<["updated", "skipped", "failed"]>;
+        path: import("zod").ZodOptional<import("zod").ZodString>;
+        git_status: import("zod").ZodOptional<import("zod").ZodString>;
+        build_status: import("zod").ZodOptional<import("zod").ZodString>;
+        message: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        path?: string | undefined;
+        git_status?: string | undefined;
+        build_status?: string | undefined;
+    }, {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        path?: string | undefined;
+        git_status?: string | undefined;
+        build_status?: string | undefined;
+    }>>;
+    next_action: import("zod").ZodObject<{
+        type: import("zod").ZodEnum<["NONE", "RETRY", "RESTART_CLAUDE", "CONTACT_SUPPORT"]>;
+        message: import("zod").ZodString;
+    }, "strict", import("zod").ZodTypeAny, {
+        type: "NONE" | "CONTACT_SUPPORT" | "RETRY" | "RESTART_CLAUDE";
+        message: string;
+    }, {
+        type: "NONE" | "CONTACT_SUPPORT" | "RETRY" | "RESTART_CLAUDE";
+        message: string;
+    }>;
+}, "strict", import("zod").ZodTypeAny, {
+    status: "ERROR" | "OK" | "PARTIAL";
+    next_action: {
+        type: "NONE" | "CONTACT_SUPPORT" | "RETRY" | "RESTART_CLAUDE";
+        message: string;
+    };
+    summary: string;
+    results?: {
+        name: string;
+        message: string;
+        from_version: string | null;
+        to_version: string;
+        action: "failed" | "skipped" | "updated";
+    }[] | undefined;
+    npm_result?: {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        from_version?: string | null | undefined;
+        to_version?: string | null | undefined;
+    } | undefined;
+    local_result?: {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        path?: string | undefined;
+        git_status?: string | undefined;
+        build_status?: string | undefined;
+    } | undefined;
+}, {
+    status: "ERROR" | "OK" | "PARTIAL";
+    next_action: {
+        type: "NONE" | "CONTACT_SUPPORT" | "RETRY" | "RESTART_CLAUDE";
+        message: string;
+    };
+    summary: string;
+    results?: {
+        name: string;
+        message: string;
+        from_version: string | null;
+        to_version: string;
+        action: "failed" | "skipped" | "updated";
+    }[] | undefined;
+    npm_result?: {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        from_version?: string | null | undefined;
+        to_version?: string | null | undefined;
+    } | undefined;
+    local_result?: {
+        message: string;
+        action: "failed" | "skipped" | "updated";
+        path?: string | undefined;
+        git_status?: string | undefined;
+        build_status?: string | undefined;
+    } | undefined;
+}>;
+export declare const skillsInputSchema: import("zod").ZodObject<{
+    action: import("zod").ZodEnum<["recommend", "execute", "status", "list"]>;
+    project_id: import("zod").ZodOptional<import("zod").ZodString>;
+    run_id: import("zod").ZodOptional<import("zod").ZodString>;
+    skill_id: import("zod").ZodOptional<import("zod").ZodString>;
+    user_intent: import("zod").ZodOptional<import("zod").ZodString>;
+    step_input: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    resume_from: import("zod").ZodOptional<import("zod").ZodString>;
+    max_recommendations: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodNumber>>;
+}, "strict", import("zod").ZodTypeAny, {
+    action: "status" | "execute" | "list" | "recommend";
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    skill_id?: string | undefined;
+    user_intent?: string | undefined;
+    step_input?: Record<string, unknown> | undefined;
+    resume_from?: string | undefined;
+    max_recommendations?: number | undefined;
+}, {
+    action: "status" | "execute" | "list" | "recommend";
+    run_id?: string | undefined;
+    project_id?: string | undefined;
+    skill_id?: string | undefined;
+    user_intent?: string | undefined;
+    step_input?: Record<string, unknown> | undefined;
+    resume_from?: string | undefined;
+    max_recommendations?: number | undefined;
+}>;
+export declare const skillsOutputSchema: import("zod").ZodObject<{
+    ok: import("zod").ZodBoolean;
+    action: import("zod").ZodEnum<["recommend", "execute", "status", "list"]>;
+    error: import("zod").ZodOptional<import("zod").ZodString>;
+    error_code: import("zod").ZodOptional<import("zod").ZodString>;
+    hint: import("zod").ZodOptional<import("zod").ZodString>;
+    recommendations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        skill_id: import("zod").ZodString;
+        title: import("zod").ZodString;
+        intent: import("zod").ZodOptional<import("zod").ZodString>;
+        match_score: import("zod").ZodNumber;
+        match_reasons: import("zod").ZodArray<import("zod").ZodString, "many">;
+    }, "strict", import("zod").ZodTypeAny, {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }, {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }>, "many">>;
+    execution: import("zod").ZodOptional<import("zod").ZodObject<{
+        execution_id: import("zod").ZodString;
+        skill_id: import("zod").ZodString;
+        status: import("zod").ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+        current_step: import("zod").ZodOptional<import("zod").ZodObject<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough">>>;
+        completed_steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        pending_steps: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        user_prompt: import("zod").ZodOptional<import("zod").ZodString>;
+        next_action: import("zod").ZodOptional<import("zod").ZodString>;
+        execution_log_path: import("zod").ZodOptional<import("zod").ZodString>;
+        evidence_paths: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: import("zod").objectOutputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    }, {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: import("zod").objectInputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    }>>;
+    available_skills: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        skill_id: import("zod").ZodString;
+        title: import("zod").ZodString;
+        intent: import("zod").ZodOptional<import("zod").ZodString>;
+        pack_id: import("zod").ZodString;
+        version: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }, {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }>, "many">>;
+    execution_status: import("zod").ZodOptional<import("zod").ZodObject<{
+        execution_id: import("zod").ZodString;
+        skill_id: import("zod").ZodString;
+        status: import("zod").ZodEnum<["running", "waiting_for_user", "completed", "failed", "aborted"]>;
+        current_step_id: import("zod").ZodOptional<import("zod").ZodString>;
+        progress: import("zod").ZodOptional<import("zod").ZodNumber>;
+        started_at: import("zod").ZodOptional<import("zod").ZodString>;
+        updated_at: import("zod").ZodOptional<import("zod").ZodString>;
+    }, "strict", import("zod").ZodTypeAny, {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        progress?: number | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+    }, {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        progress?: number | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+    }>>;
+}, "strict", import("zod").ZodTypeAny, {
+    ok: boolean;
+    action: "status" | "execute" | "list" | "recommend";
+    error?: string | undefined;
+    error_code?: string | undefined;
+    hint?: string | undefined;
+    recommendations?: {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }[] | undefined;
+    execution?: {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: import("zod").objectOutputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    } | undefined;
+    available_skills?: {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }[] | undefined;
+    execution_status?: {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        progress?: number | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+    } | undefined;
+}, {
+    ok: boolean;
+    action: "status" | "execute" | "list" | "recommend";
+    error?: string | undefined;
+    error_code?: string | undefined;
+    hint?: string | undefined;
+    recommendations?: {
+        title: string;
+        skill_id: string;
+        match_score: number;
+        match_reasons: string[];
+        intent?: string | undefined;
+    }[] | undefined;
+    execution?: {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        next_action?: string | undefined;
+        current_step?: import("zod").objectInputType<{
+            id: import("zod").ZodOptional<import("zod").ZodString>;
+            tool: import("zod").ZodOptional<import("zod").ZodString>;
+            mode: import("zod").ZodOptional<import("zod").ZodString>;
+            result: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+        completed_steps?: string[] | undefined;
+        pending_steps?: string[] | undefined;
+        user_prompt?: string | undefined;
+        execution_log_path?: string | undefined;
+        evidence_paths?: string[] | undefined;
+    } | undefined;
+    available_skills?: {
+        title: string;
+        skill_id: string;
+        pack_id: string;
+        version?: string | undefined;
+        intent?: string | undefined;
+    }[] | undefined;
+    execution_status?: {
+        status: "aborted" | "running" | "completed" | "failed" | "waiting_for_user";
+        skill_id: string;
+        execution_id: string;
+        updated_at?: string | undefined;
+        progress?: number | undefined;
+        started_at?: string | undefined;
+        current_step_id?: string | undefined;
+    } | undefined;
+}>;