code-ai-installer 3.0.0 → 4.0.1-a

package/dist/shared/tools.d.ts

@@ -0,0 +1,3021 @@
+import { z } from "zod";
+/**
+ * MCP tool I/O contracts — one schema pair per tool.
+ *
+ * Each tool exports `<ToolName>Input` and `<ToolName>Output` zod schemas.
+ * The MCP server (packages/mcp) uses these for runtime validation; consumers
+ * (claude code, tests) get typed call signatures via z.infer.
+ *
+ * Phase 1 baseline (18 tools) — from packages/mcp/README.md.
+ * Phase 2 dev-domain (8 tools) — stubbed at the end.
+ */
+/** Stable task id (one ongoing task = one classify→advance→sign-off thread). */
+export declare const TaskId: z.ZodString;
+export type TaskId = z.infer<typeof TaskId>;
+/** ADR identifier — "ADR-{domain}-{ordinal}" or supersedes-style "ADR-CC-2-001". */
+export declare const AdrId: z.ZodString;
+export type AdrId = z.infer<typeof AdrId>;
+/** Generic options for request_decision. */
+export declare const DecisionOption: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type DecisionOption = z.infer<typeof DecisionOption>;
+/** A single error item for structured exception output. */
+export declare const ExceptionItem: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    evidence: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ExceptionItem = z.infer<typeof ExceptionItem>;
+export declare const LoadRoleInput: z.ZodObject<{
+    role_name: z.ZodString;
+    domain: z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>;
+}, z.core.$strip>;
+export declare const LoadRoleOutput: z.ZodObject<{
+    role: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        kind: z.ZodDefault<z.ZodEnum<{
+            gate: "gate";
+            meta: "meta";
+        }>>;
+        signs_off_at: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>>>;
+        tool_allowlist: z.ZodString;
+        budget_lines: z.ZodDefault<z.ZodNumber>;
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+    }, z.core.$strip>;
+    role_body: z.ZodString;
+    persona: z.ZodObject<{
+        base_version: z.ZodString;
+        user_handle: z.ZodNullable<z.ZodString>;
+        epistemic_stance: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            provenance: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    adr: "adr";
+                    diary: "diary";
+                    conversation: "conversation";
+                    drawer: "drawer";
+                    manual: "manual";
+                }>;
+                ref: z.ZodString;
+                date: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        defaults: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            provenance: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    adr: "adr";
+                    diary: "diary";
+                    conversation: "conversation";
+                    drawer: "drawer";
+                    manual: "manual";
+                }>;
+                ref: z.ZodString;
+                date: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        values: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            provenance: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    adr: "adr";
+                    diary: "diary";
+                    conversation: "conversation";
+                    drawer: "drawer";
+                    manual: "manual";
+                }>;
+                ref: z.ZodString;
+                date: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        style: z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            provenance: z.ZodArray<z.ZodObject<{
+                source: z.ZodEnum<{
+                    adr: "adr";
+                    diary: "diary";
+                    conversation: "conversation";
+                    drawer: "drawer";
+                    manual: "manual";
+                }>;
+                ref: z.ZodString;
+                date: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    tool_allowlist: z.ZodArray<z.ZodString>;
+    available_skills: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LoadRoleInput = z.infer<typeof LoadRoleInput>;
+export type LoadRoleOutput = z.infer<typeof LoadRoleOutput>;
+export declare const ListSkillsInput: z.ZodObject<{
+    domain: z.ZodOptional<z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        mandatory: "mandatory";
+        triggered: "triggered";
+        reference: "reference";
+        discretionary: "discretionary";
+    }>>;
+    gate: z.ZodOptional<z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>>;
+    tech: z.ZodOptional<z.ZodString>;
+    topic: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListSkillsOutput: z.ZodObject<{
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            mandatory: "mandatory";
+            triggered: "triggered";
+            reference: "reference";
+            discretionary: "discretionary";
+        }>;
+        gates: z.ZodArray<z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListSkillsInput = z.infer<typeof ListSkillsInput>;
+export type ListSkillsOutput = z.infer<typeof ListSkillsOutput>;
+export declare const GetSkillInput: z.ZodObject<{
+    name: z.ZodString;
+    domain: z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>;
+    task_id: z.ZodOptional<z.ZodString>;
+    gate: z.ZodOptional<z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>>;
+}, z.core.$strip>;
+export declare const GetSkillOutput: z.ZodObject<{
+    frontmatter: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        type: z.ZodEnum<{
+            mandatory: "mandatory";
+            triggered: "triggered";
+            reference: "reference";
+            discretionary: "discretionary";
+        }>;
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        owners: z.ZodArray<z.ZodString>;
+        gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>>>;
+        tech: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            mcp: "mcp";
+            typescript: "typescript";
+            node: "node";
+            react: "react";
+            python: "python";
+            go: "go";
+            rust: "rust";
+            monaco: "monaco";
+            vscode: "vscode";
+            mongodb: "mongodb";
+            postgres: "postgres";
+            docker: "docker";
+            playwright: "playwright";
+            vitest: "vitest";
+            general: "general";
+            a11y: "a11y";
+            css: "css";
+            express: "express";
+            n8n: "n8n";
+            rtk: "rtk";
+            tailwind: "tailwind";
+            tanstack: "tanstack";
+            wix: "wix";
+            bun: "bun";
+            biome: "biome";
+            k8s: "k8s";
+            zustand: "zustand";
+            stryker: "stryker";
+            mutmut: "mutmut";
+            "fast-check": "fast-check";
+            hypothesis: "hypothesis";
+            eslint: "eslint";
+            ruff: "ruff";
+            pytest: "pytest";
+            faker: "faker";
+            factory_boy: "factory_boy";
+            husky: "husky";
+            "pre-commit": "pre-commit";
+        }>>>;
+        topic: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            general: "general";
+            a11y: "a11y";
+            architecture: "architecture";
+            refactoring: "refactoring";
+            testing: "testing";
+            security: "security";
+            performance: "performance";
+            documentation: "documentation";
+            "design-patterns": "design-patterns";
+            "data-modelling": "data-modelling";
+            legacy: "legacy";
+            ux: "ux";
+            review: "review";
+            ops: "ops";
+            pm: "pm";
+            orchestration: "orchestration";
+            qa: "qa";
+            "design-systems": "design-systems";
+            observability: "observability";
+            compliance: "compliance";
+            release: "release";
+        }>>>;
+        triggers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        related: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        budget_lines: z.ZodDefault<z.ZodNumber>;
+        schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+        license: z.ZodOptional<z.ZodString>;
+        source: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
+    }, z.core.$strip>;
+    body: z.ZodString;
+}, z.core.$strip>;
+export type GetSkillInput = z.infer<typeof GetSkillInput>;
+export type GetSkillOutput = z.infer<typeof GetSkillOutput>;
+export declare const RequestDecisionInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RequestDecisionOutput: z.ZodObject<{
+    chosen_option_id: z.ZodString;
+    signer: z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>;
+    adr_id: z.ZodString;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type RequestDecisionInput = z.infer<typeof RequestDecisionInput>;
+export type RequestDecisionOutput = z.infer<typeof RequestDecisionOutput>;
+export declare const RecordDecisionInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    question: z.ZodString;
+    options: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    chosen_option_id: z.ZodString;
+    rationale: z.ZodString;
+    signer: z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>;
+    supersedes: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RecordDecisionOutput: z.ZodObject<{
+    adr_id: z.ZodString;
+    adr_path: z.ZodString;
+    drawer_id: z.ZodString;
+    kg_triple_id: z.ZodString;
+}, z.core.$strip>;
+export type RecordDecisionInput = z.infer<typeof RecordDecisionInput>;
+export type RecordDecisionOutput = z.infer<typeof RecordDecisionOutput>;
+export declare const ClassifyGateInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    outcome: z.ZodEnum<{
+        auto_resolve: "auto_resolve";
+        fork: "fork";
+        exception: "exception";
+    }>;
+    rationale: z.ZodString;
+}, z.core.$strip>;
+export declare const ClassifyGateOutput: z.ZodObject<{
+    acknowledged: z.ZodLiteral<true>;
+    next_required_action: z.ZodEnum<{
+        produce_artifact: "produce_artifact";
+        open_request_decision: "open_request_decision";
+        open_report_exception: "open_report_exception";
+    }>;
+}, z.core.$strip>;
+export type ClassifyGateInput = z.infer<typeof ClassifyGateInput>;
+export type ClassifyGateOutput = z.infer<typeof ClassifyGateOutput>;
+export declare const AdvanceGateInput: z.ZodObject<{
+    task_id: z.ZodString;
+    mode: z.ZodEnum<{
+        full: "full";
+        bugfix: "bugfix";
+        hotfix: "hotfix";
+    }>;
+    from_gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    to_gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    handoff_string: z.ZodString;
+}, z.core.$strip>;
+export declare const AdvanceGateOutput: z.ZodObject<{
+    task_id: z.ZodString;
+    current_gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    allowed_tools: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AdvanceGateInput = z.infer<typeof AdvanceGateInput>;
+export type AdvanceGateOutput = z.infer<typeof AdvanceGateOutput>;
+export declare const CurrentGateInput: z.ZodObject<{
+    task_id: z.ZodString;
+}, z.core.$strip>;
+export declare const CurrentGateOutput: z.ZodObject<{
+    mode: z.ZodEnum<{
+        full: "full";
+        bugfix: "bugfix";
+        hotfix: "hotfix";
+    }>;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    allowed_tools: z.ZodArray<z.ZodString>;
+    required_handoff_fields: z.ZodArray<z.ZodString>;
+    classification_pending: z.ZodBoolean;
+}, z.core.$strip>;
+export type CurrentGateInput = z.infer<typeof CurrentGateInput>;
+export type CurrentGateOutput = z.infer<typeof CurrentGateOutput>;
+export declare const SignOffInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    signer: z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>;
+    evidence: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const SignOffOutput: z.ZodObject<{
+    signed: z.ZodLiteral<true>;
+    signer: z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type SignOffInput = z.infer<typeof SignOffInput>;
+export type SignOffOutput = z.infer<typeof SignOffOutput>;
+export declare const SubmitArtifactInput: z.ZodObject<{
+    task_id: z.ZodString;
+    class: z.ZodEnum<{
+        skill: "skill";
+        adr: "adr";
+        persona: "persona";
+        role: "role";
+        diary: "diary";
+        working_report: "working_report";
+        handoff: "handoff";
+        memory_index: "memory_index";
+    }>;
+    path: z.ZodString;
+    content: z.ZodString;
+    frontmatter: z.ZodOptional<z.ZodUnknown>;
+    gate: z.ZodOptional<z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>>;
+}, z.core.$strip>;
+export declare const SubmitArtifactOutput: z.ZodObject<{
+    written: z.ZodLiteral<true>;
+    path: z.ZodString;
+    line_count: z.ZodNumber;
+    cap: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type SubmitArtifactInput = z.infer<typeof SubmitArtifactInput>;
+export type SubmitArtifactOutput = z.infer<typeof SubmitArtifactOutput>;
+export declare const VerifyClaimInput: z.ZodObject<{
+    task_id: z.ZodString;
+    claim_type: z.ZodEnum<{
+        custom: "custom";
+        tests_pass: "tests_pass";
+        build_succeeds: "build_succeeds";
+        lint_clean: "lint_clean";
+        no_orphan_skills: "no_orphan_skills";
+        owners_present: "owners_present";
+        vocab_valid: "vocab_valid";
+    }>;
+    args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const VerifyClaimOutput: z.ZodObject<{
+    verified: z.ZodBoolean;
+    evidence: z.ZodUnknown;
+    failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type VerifyClaimInput = z.infer<typeof VerifyClaimInput>;
+export type VerifyClaimOutput = z.infer<typeof VerifyClaimOutput>;
+export declare const ReportExceptionInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    what_failed: z.ZodString;
+    breakdown: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ReportExceptionOutput: z.ZodObject<{
+    exception_id: z.ZodString;
+    surfaced_to: z.ZodEnum<{
+        den: "den";
+        mcp: "mcp";
+        system: "system";
+    }>;
+}, z.core.$strip>;
+export type ReportExceptionInput = z.infer<typeof ReportExceptionInput>;
+export type ReportExceptionOutput = z.infer<typeof ReportExceptionOutput>;
+export declare const GetArtifactInput: z.ZodObject<{
+    task_id: z.ZodString;
+    gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+        STRATEGIST: "STRATEGIST";
+        RESEARCHER: "RESEARCHER";
+        COPYWRITER: "COPYWRITER";
+        VISUAL_CONCEPT: "VISUAL_CONCEPT";
+        REVIEWER: "REVIEWER";
+        RELEASE_GATE: "RELEASE_GATE";
+        INTERVIEWER: "INTERVIEWER";
+        DATA_ANALYST: "DATA_ANALYST";
+        MEDIATOR: "MEDIATOR";
+        DESIGNER: "DESIGNER";
+        LAYOUTER: "LAYOUTER";
+        DISCOVERY: "DISCOVERY";
+        PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+        UX_DESIGNER: "UX_DESIGNER";
+        TECH_LEAD: "TECH_LEAD";
+    }>;
+    format: z.ZodDefault<z.ZodEnum<{
+        raw: "raw";
+        summary: "summary";
+    }>>;
+}, z.core.$strip>;
+export declare const GetArtifactOutput: z.ZodObject<{
+    exists: z.ZodBoolean;
+    path: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GetArtifactInput = z.infer<typeof GetArtifactInput>;
+export type GetArtifactOutput = z.infer<typeof GetArtifactOutput>;
+export declare const ListArtifactsInput: z.ZodObject<{
+    task_id: z.ZodString;
+}, z.core.$strip>;
+export declare const ListArtifactsOutput: z.ZodObject<{
+    artifacts: z.ZodArray<z.ZodObject<{
+        gate: z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>;
+        class: z.ZodEnum<{
+            skill: "skill";
+            adr: "adr";
+            persona: "persona";
+            role: "role";
+            diary: "diary";
+            working_report: "working_report";
+            handoff: "handoff";
+            memory_index: "memory_index";
+        }>;
+        path: z.ZodString;
+        line_count: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListArtifactsInput = z.infer<typeof ListArtifactsInput>;
+export type ListArtifactsOutput = z.infer<typeof ListArtifactsOutput>;
+export declare const AuditTrailInput: z.ZodObject<{
+    task_id: z.ZodString;
+}, z.core.$strip>;
+export declare const AuditTrailOutput: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        timestamp: z.ZodString;
+        kind: z.ZodEnum<{
+            classify_gate: "classify_gate";
+            advance_gate: "advance_gate";
+            sign_off: "sign_off";
+            submit_artifact: "submit_artifact";
+            request_decision: "request_decision";
+            record_decision: "record_decision";
+            report_exception: "report_exception";
+            circuit_breaker_trip: "circuit_breaker_trip";
+        }>;
+        gate: z.ZodOptional<z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>>;
+        details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AuditTrailInput = z.infer<typeof AuditTrailInput>;
+export type AuditTrailOutput = z.infer<typeof AuditTrailOutput>;
+export declare const RecentDecisionsInput: z.ZodObject<{
+    domain: z.ZodOptional<z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>>;
+    since: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const RecentDecisionsOutput: z.ZodObject<{
+    decisions: z.ZodArray<z.ZodObject<{
+        adr_id: z.ZodString;
+        timestamp: z.ZodString;
+        question: z.ZodString;
+        chosen_option_id: z.ZodString;
+        signer: z.ZodEnum<{
+            den: "den";
+            mcp: "mcp";
+            system: "system";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RecentDecisionsInput = z.infer<typeof RecentDecisionsInput>;
+export type RecentDecisionsOutput = z.infer<typeof RecentDecisionsOutput>;
+export declare const RegenerateManifestInput: z.ZodObject<{
+    domain: z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>;
+    apply: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const RegenerateManifestOutput: z.ZodObject<{
+    agents_yaml_path: z.ZodString;
+    agents_md_path: z.ZodString;
+    diff: z.ZodString;
+    applied: z.ZodBoolean;
+}, z.core.$strip>;
+export type RegenerateManifestInput = z.infer<typeof RegenerateManifestInput>;
+export type RegenerateManifestOutput = z.infer<typeof RegenerateManifestOutput>;
+export declare const RunDriftAuditInput: z.ZodObject<{
+    domain: z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>;
+}, z.core.$strip>;
+export declare const RunDriftAuditOutput: z.ZodObject<{
+    orphan_skills: z.ZodArray<z.ZodString>;
+    phantom_skills: z.ZodArray<z.ZodString>;
+    yaml_skew: z.ZodArray<z.ZodObject<{
+        skill: z.ZodString;
+        field: z.ZodString;
+        yaml_value: z.ZodUnknown;
+        md_value: z.ZodUnknown;
+    }, z.core.$strip>>;
+    unowned: z.ZodArray<z.ZodString>;
+    missing_backlinks: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunDriftAuditInput = z.infer<typeof RunDriftAuditInput>;
+export type RunDriftAuditOutput = z.infer<typeof RunDriftAuditOutput>;
+export declare const AuditBudgetComplianceInput: z.ZodObject<{
+    domain: z.ZodUnion<readonly [z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>, z.ZodLiteral<"*">]>;
+}, z.core.$strip>;
+export declare const AuditBudgetComplianceOutput: z.ZodObject<{
+    schema_violations: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        file: z.ZodString;
+        file_type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        declared_budget: z.ZodNumber;
+        schema_max: z.ZodNumber;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    budget_violations: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        file: z.ZodString;
+        file_type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        declared_budget: z.ZodNumber;
+        actual_lines: z.ZodNumber;
+        overage: z.ZodNumber;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    scanned: z.ZodObject<{
+        agents: z.ZodNumber;
+        skills: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AuditBudgetComplianceInput = z.infer<typeof AuditBudgetComplianceInput>;
+export type AuditBudgetComplianceOutput = z.infer<typeof AuditBudgetComplianceOutput>;
+export declare const AuditBilocaleParityInput: z.ZodObject<{
+    domain: z.ZodUnion<readonly [z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>, z.ZodLiteral<"*">]>;
+}, z.core.$strip>;
+export declare const AuditBilocaleParityOutput: z.ZodObject<{
+    declared_mismatches: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        id: z.ZodString;
+        file_type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        ru_path: z.ZodString;
+        en_path: z.ZodString;
+        ru_declared: z.ZodNumber;
+        en_declared: z.ZodNumber;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    actual_mismatches: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        id: z.ZodString;
+        file_type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        ru_path: z.ZodString;
+        en_path: z.ZodString;
+        ru_actual: z.ZodNumber;
+        en_actual: z.ZodNumber;
+        diff: z.ZodNumber;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    orphans: z.ZodArray<z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        id: z.ZodString;
+        file_type: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        present_locale: z.ZodEnum<{
+            ru: "ru";
+            en: "en";
+        }>;
+        present_path: z.ZodString;
+        missing_locale: z.ZodEnum<{
+            ru: "ru";
+            en: "en";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    scanned: z.ZodObject<{
+        pairs: z.ZodNumber;
+        agents: z.ZodNumber;
+        skills: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AuditBilocaleParityInput = z.infer<typeof AuditBilocaleParityInput>;
+export type AuditBilocaleParityOutput = z.infer<typeof AuditBilocaleParityOutput>;
+export declare const AggregateRunMetricsInput: z.ZodObject<{
+    min_runs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const AggregateRunMetricsOutput: z.ZodObject<{
+    runs_in_ledger: z.ZodNumber;
+    runs_completed: z.ZodNumber;
+    min_runs: z.ZodNumber;
+    met_threshold: z.ZodBoolean;
+    per_workflow: z.ZodArray<z.ZodObject<{
+        mode: z.ZodEnum<{
+            full: "full";
+            bugfix: "bugfix";
+            hotfix: "hotfix";
+        }>;
+        runs: z.ZodNumber;
+        completed: z.ZodNumber;
+        avg_dev_rollbacks: z.ZodNumber;
+        circuit_breaker_trips: z.ZodNumber;
+        total_exceptions: z.ZodNumber;
+    }, z.core.$strip>>;
+    per_agent: z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        gate: z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+            STRATEGIST: "STRATEGIST";
+            RESEARCHER: "RESEARCHER";
+            COPYWRITER: "COPYWRITER";
+            VISUAL_CONCEPT: "VISUAL_CONCEPT";
+            REVIEWER: "REVIEWER";
+            RELEASE_GATE: "RELEASE_GATE";
+            INTERVIEWER: "INTERVIEWER";
+            DATA_ANALYST: "DATA_ANALYST";
+            MEDIATOR: "MEDIATOR";
+            DESIGNER: "DESIGNER";
+            LAYOUTER: "LAYOUTER";
+            DISCOVERY: "DISCOVERY";
+            PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+            UX_DESIGNER: "UX_DESIGNER";
+            TECH_LEAD: "TECH_LEAD";
+        }>;
+        runs_involved: z.ZodNumber;
+        reworked: z.ZodNumber;
+        first_try_rate: z.ZodNumber;
+        exceptions: z.ZodNumber;
+        classification_breakdown: z.ZodObject<{
+            auto_resolve: z.ZodNumber;
+            fork: z.ZodNumber;
+            exception: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    per_skill: z.ZodArray<z.ZodObject<{
+        skill: z.ZodString;
+        invocations: z.ZodNumber;
+        runs_invoked_in: z.ZodNumber;
+        gates: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    notes: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type AggregateRunMetricsInput = z.infer<typeof AggregateRunMetricsInput>;
+export type AggregateRunMetricsOutput = z.infer<typeof AggregateRunMetricsOutput>;
+/**
+ * The kind of change a proposal requests. Maps 1:1 to the autonomy-matrix risk
+ * tiers (ADR-DEV-122 agent.md): edit_minor → low (auto when gate off),
+ * add_asset → additive (auto when gate off, dedup-guarded in item 4c),
+ * destructive → high (always human, even in autonomy).
+ */
+export declare const ProposalChangeKind: z.ZodEnum<{
+    edit_minor: "edit_minor";
+    add_asset: "add_asset";
+    destructive: "destructive";
+}>;
+export type ProposalChangeKind = z.infer<typeof ProposalChangeKind>;
+/** Risk tier surfaced on the record so the approval layer (4b) routes without re-deriving. */
+export declare const ProposalRisk: z.ZodEnum<{
+    low: "low";
+    high: "high";
+    additive: "additive";
+}>;
+export type ProposalRisk = z.infer<typeof ProposalRisk>;
+/**
+ * Proposal lifecycle status. 4a (this ADR) only ever writes "pending"; the rest
+ * are forward-declared so the approval/apply layer (4b) extends behaviour without
+ * reshaping the record. list_proposals tolerates all of them.
+ */
+export declare const ProposalStatus: z.ZodEnum<{
+    applied: "applied";
+    pending: "pending";
+    approved: "approved";
+    rejected: "rejected";
+    superseded: "superseded";
+}>;
+export type ProposalStatus = z.infer<typeof ProposalStatus>;
+/** What asset a proposal targets. For add_asset, `name` is the proposed new asset's name. */
+export declare const ProposalTarget: z.ZodObject<{
+    domain: z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>;
+    asset: z.ZodEnum<{
+        agent: "agent";
+        skill: "skill";
+    }>;
+    name: z.ZodString;
+}, z.core.$strip>;
+export type ProposalTarget = z.infer<typeof ProposalTarget>;
+export declare const ProposeChangeInput: z.ZodObject<{
+    target: z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        asset: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    change_kind: z.ZodEnum<{
+        edit_minor: "edit_minor";
+        add_asset: "add_asset";
+        destructive: "destructive";
+    }>;
+    rationale: z.ZodString;
+    evidence: z.ZodString;
+    threshold_met: z.ZodBoolean;
+    draft: z.ZodString;
+}, z.core.$strip>;
+export declare const ProposeChangeOutput: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        applied: "applied";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    risk: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        additive: "additive";
+    }>;
+    path: z.ZodString;
+}, z.core.$strip>;
+export type ProposeChangeInput = z.infer<typeof ProposeChangeInput>;
+export type ProposeChangeOutput = z.infer<typeof ProposeChangeOutput>;
+/** One stored proposal. Shared by the store reader and list_proposals output. */
+export declare const ProposalRecord: z.ZodObject<{
+    id: z.ZodString;
+    created_at: z.ZodString;
+    status: z.ZodEnum<{
+        applied: "applied";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    risk: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        additive: "additive";
+    }>;
+    target: z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        asset: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    change_kind: z.ZodEnum<{
+        edit_minor: "edit_minor";
+        add_asset: "add_asset";
+        destructive: "destructive";
+    }>;
+    rationale: z.ZodString;
+    evidence: z.ZodString;
+    threshold_met: z.ZodBoolean;
+    draft: z.ZodString;
+}, z.core.$strip>;
+export type ProposalRecord = z.infer<typeof ProposalRecord>;
+export declare const ListProposalsInput: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<{
+        applied: "applied";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>>;
+    risk: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        additive: "additive";
+    }>>;
+    domain: z.ZodOptional<z.ZodEnum<{
+        development: "development";
+        content: "content";
+        analytics: "analytics";
+        product: "product";
+    }>>;
+}, z.core.$strip>;
+export declare const ListProposalsOutput: z.ZodObject<{
+    proposals: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        created_at: z.ZodString;
+        status: z.ZodEnum<{
+            applied: "applied";
+            pending: "pending";
+            approved: "approved";
+            rejected: "rejected";
+            superseded: "superseded";
+        }>;
+        risk: z.ZodEnum<{
+            low: "low";
+            high: "high";
+            additive: "additive";
+        }>;
+        target: z.ZodObject<{
+            domain: z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>;
+            asset: z.ZodEnum<{
+                agent: "agent";
+                skill: "skill";
+            }>;
+            name: z.ZodString;
+        }, z.core.$strip>;
+        change_kind: z.ZodEnum<{
+            edit_minor: "edit_minor";
+            add_asset: "add_asset";
+            destructive: "destructive";
+        }>;
+        rationale: z.ZodString;
+        evidence: z.ZodString;
+        threshold_met: z.ZodBoolean;
+        draft: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ListProposalsInput = z.infer<typeof ListProposalsInput>;
+export type ListProposalsOutput = z.infer<typeof ListProposalsOutput>;
+/**
+ * A status-transition event for a proposal. Appended to proposals.jsonl as a NEW line
+ * (event-sourcing — the original ProposalRecord is never rewritten). readProposals folds
+ * the latest event per id into the record's effective status. ADR-DEV-124.
+ */
+export declare const ProposalReviewEvent: z.ZodObject<{
+    kind: z.ZodLiteral<"review">;
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        applied: "applied";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    decided_by: z.ZodEnum<{
+        den: "den";
+        auditor_auto: "auditor_auto";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+    reviewed_at: z.ZodString;
+}, z.core.$strip>;
+export type ProposalReviewEvent = z.infer<typeof ProposalReviewEvent>;
+export declare const ReviewProposalInput: z.ZodObject<{
+    id: z.ZodString;
+    decision: z.ZodEnum<{
+        applied: "applied";
+        approve: "approve";
+        reject: "reject";
+    }>;
+    decided_by: z.ZodEnum<{
+        den: "den";
+        auditor_auto: "auditor_auto";
+    }>;
+    note: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ReviewProposalOutput: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        applied: "applied";
+        pending: "pending";
+        approved: "approved";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    risk: z.ZodEnum<{
+        low: "low";
+        high: "high";
+        additive: "additive";
+    }>;
+    decided_by: z.ZodString;
+    target: z.ZodObject<{
+        domain: z.ZodEnum<{
+            development: "development";
+            content: "content";
+            analytics: "analytics";
+            product: "product";
+        }>;
+        asset: z.ZodEnum<{
+            agent: "agent";
+            skill: "skill";
+        }>;
+        name: z.ZodString;
+    }, z.core.$strip>;
+    next_step: z.ZodString;
+}, z.core.$strip>;
+export type ReviewProposalInput = z.infer<typeof ReviewProposalInput>;
+export type ReviewProposalOutput = z.infer<typeof ReviewProposalOutput>;
+export declare const RunTestsInput: z.ZodObject<{
+    task_id: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RunTestsOutput: z.ZodObject<{
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    duration_ms: z.ZodNumber;
+    failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type RunTestsInput = z.infer<typeof RunTestsInput>;
+export type RunTestsOutput = z.infer<typeof RunTestsOutput>;
+export declare const ApplyDiffInput: z.ZodObject<{
+    task_id: z.ZodString;
+    diff: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const ApplyDiffOutput: z.ZodObject<{
+    files_changed: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ApplyDiffInput = z.infer<typeof ApplyDiffInput>;
+export type ApplyDiffOutput = z.infer<typeof ApplyDiffOutput>;
+export declare const GitCommitInput: z.ZodObject<{
+    task_id: z.ZodString;
+    message: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const GitCommitOutput: z.ZodObject<{
+    sha: z.ZodString;
+}, z.core.$strip>;
+export type GitCommitInput = z.infer<typeof GitCommitInput>;
+export type GitCommitOutput = z.infer<typeof GitCommitOutput>;
+export declare const CheckLintInput: z.ZodObject<{
+    task_id: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const CheckLintOutput: z.ZodObject<{
+    clean: z.ZodBoolean;
+    issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type CheckLintInput = z.infer<typeof CheckLintInput>;
+export type CheckLintOutput = z.infer<typeof CheckLintOutput>;
+export declare const BuildInput: z.ZodObject<{
+    task_id: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const BuildOutput: z.ZodObject<{
+    succeeded: z.ZodBoolean;
+    errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type BuildInput = z.infer<typeof BuildInput>;
+export type BuildOutput = z.infer<typeof BuildOutput>;
+export declare const DependencySupplyChainInput: z.ZodObject<{
+    task_id: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DependencySupplyChainOutput: z.ZodObject<{
+    vulnerabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+    total_deps: z.ZodNumber;
+}, z.core.$strip>;
+export type DependencySupplyChainInput = z.infer<typeof DependencySupplyChainInput>;
+export type DependencySupplyChainOutput = z.infer<typeof DependencySupplyChainOutput>;
+export declare const DockerComposeInput: z.ZodObject<{
+    task_id: z.ZodString;
+    command: z.ZodEnum<{
+        up: "up";
+        down: "down";
+        ps: "ps";
+        logs: "logs";
+    }>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const DockerComposeOutput: z.ZodObject<{
+    exit_code: z.ZodNumber;
+    stdout: z.ZodString;
+    stderr: z.ZodString;
+}, z.core.$strip>;
+export type DockerComposeInput = z.infer<typeof DockerComposeInput>;
+export type DockerComposeOutput = z.infer<typeof DockerComposeOutput>;
+export declare const E2EPlaywrightInput: z.ZodObject<{
+    task_id: z.ZodString;
+    spec: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const E2EPlaywrightOutput: z.ZodObject<{
+    passed: z.ZodNumber;
+    failed: z.ZodNumber;
+    failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        evidence: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type E2EPlaywrightInput = z.infer<typeof E2EPlaywrightInput>;
+export type E2EPlaywrightOutput = z.infer<typeof E2EPlaywrightOutput>;
+export declare const TOOL_REGISTRY: {
+    readonly load_role: {
+        readonly input: z.ZodObject<{
+            role_name: z.ZodString;
+            domain: z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            role: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                kind: z.ZodDefault<z.ZodEnum<{
+                    gate: "gate";
+                    meta: "meta";
+                }>>;
+                signs_off_at: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>>>;
+                tool_allowlist: z.ZodString;
+                budget_lines: z.ZodDefault<z.ZodNumber>;
+                schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+            }, z.core.$strip>;
+            role_body: z.ZodString;
+            persona: z.ZodObject<{
+                base_version: z.ZodString;
+                user_handle: z.ZodNullable<z.ZodString>;
+                epistemic_stance: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    provenance: z.ZodArray<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            adr: "adr";
+                            diary: "diary";
+                            conversation: "conversation";
+                            drawer: "drawer";
+                            manual: "manual";
+                        }>;
+                        ref: z.ZodString;
+                        date: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                defaults: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    provenance: z.ZodArray<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            adr: "adr";
+                            diary: "diary";
+                            conversation: "conversation";
+                            drawer: "drawer";
+                            manual: "manual";
+                        }>;
+                        ref: z.ZodString;
+                        date: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                values: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    provenance: z.ZodArray<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            adr: "adr";
+                            diary: "diary";
+                            conversation: "conversation";
+                            drawer: "drawer";
+                            manual: "manual";
+                        }>;
+                        ref: z.ZodString;
+                        date: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                style: z.ZodArray<z.ZodObject<{
+                    value: z.ZodString;
+                    provenance: z.ZodArray<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            adr: "adr";
+                            diary: "diary";
+                            conversation: "conversation";
+                            drawer: "drawer";
+                            manual: "manual";
+                        }>;
+                        ref: z.ZodString;
+                        date: z.ZodString;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            tool_allowlist: z.ZodArray<z.ZodString>;
+            available_skills: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly list_skills: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodOptional<z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>>;
+            type: z.ZodOptional<z.ZodEnum<{
+                mandatory: "mandatory";
+                triggered: "triggered";
+                reference: "reference";
+                discretionary: "discretionary";
+            }>>;
+            gate: z.ZodOptional<z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>>;
+            tech: z.ZodOptional<z.ZodString>;
+            topic: z.ZodOptional<z.ZodString>;
+            owner: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            skills: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                type: z.ZodEnum<{
+                    mandatory: "mandatory";
+                    triggered: "triggered";
+                    reference: "reference";
+                    discretionary: "discretionary";
+                }>;
+                gates: z.ZodArray<z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly get_skill: {
+        readonly input: z.ZodObject<{
+            name: z.ZodString;
+            domain: z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>;
+            task_id: z.ZodOptional<z.ZodString>;
+            gate: z.ZodOptional<z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            frontmatter: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                type: z.ZodEnum<{
+                    mandatory: "mandatory";
+                    triggered: "triggered";
+                    reference: "reference";
+                    discretionary: "discretionary";
+                }>;
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                owners: z.ZodArray<z.ZodString>;
+                gates: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>>>;
+                tech: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    mcp: "mcp";
+                    typescript: "typescript";
+                    node: "node";
+                    react: "react";
+                    python: "python";
+                    go: "go";
+                    rust: "rust";
+                    monaco: "monaco";
+                    vscode: "vscode";
+                    mongodb: "mongodb";
+                    postgres: "postgres";
+                    docker: "docker";
+                    playwright: "playwright";
+                    vitest: "vitest";
+                    general: "general";
+                    a11y: "a11y";
+                    css: "css";
+                    express: "express";
+                    n8n: "n8n";
+                    rtk: "rtk";
+                    tailwind: "tailwind";
+                    tanstack: "tanstack";
+                    wix: "wix";
+                    bun: "bun";
+                    biome: "biome";
+                    k8s: "k8s";
+                    zustand: "zustand";
+                    stryker: "stryker";
+                    mutmut: "mutmut";
+                    "fast-check": "fast-check";
+                    hypothesis: "hypothesis";
+                    eslint: "eslint";
+                    ruff: "ruff";
+                    pytest: "pytest";
+                    faker: "faker";
+                    factory_boy: "factory_boy";
+                    husky: "husky";
+                    "pre-commit": "pre-commit";
+                }>>>;
+                topic: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    general: "general";
+                    a11y: "a11y";
+                    architecture: "architecture";
+                    refactoring: "refactoring";
+                    testing: "testing";
+                    security: "security";
+                    performance: "performance";
+                    documentation: "documentation";
+                    "design-patterns": "design-patterns";
+                    "data-modelling": "data-modelling";
+                    legacy: "legacy";
+                    ux: "ux";
+                    review: "review";
+                    ops: "ops";
+                    pm: "pm";
+                    orchestration: "orchestration";
+                    qa: "qa";
+                    "design-systems": "design-systems";
+                    observability: "observability";
+                    compliance: "compliance";
+                    release: "release";
+                }>>>;
+                triggers: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                related: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                budget_lines: z.ZodDefault<z.ZodNumber>;
+                schema_version: z.ZodDefault<z.ZodLiteral<1>>;
+                license: z.ZodOptional<z.ZodString>;
+                source: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString]>>;
+            }, z.core.$strip>;
+            body: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly request_decision: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            question: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            context: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            chosen_option_id: z.ZodString;
+            signer: z.ZodEnum<{
+                den: "den";
+                mcp: "mcp";
+                system: "system";
+            }>;
+            adr_id: z.ZodString;
+            timestamp: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly record_decision: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            question: z.ZodString;
+            options: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            chosen_option_id: z.ZodString;
+            rationale: z.ZodString;
+            signer: z.ZodEnum<{
+                den: "den";
+                mcp: "mcp";
+                system: "system";
+            }>;
+            supersedes: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            adr_id: z.ZodString;
+            adr_path: z.ZodString;
+            drawer_id: z.ZodString;
+            kg_triple_id: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly classify_gate: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            outcome: z.ZodEnum<{
+                auto_resolve: "auto_resolve";
+                fork: "fork";
+                exception: "exception";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            acknowledged: z.ZodLiteral<true>;
+            next_required_action: z.ZodEnum<{
+                produce_artifact: "produce_artifact";
+                open_request_decision: "open_request_decision";
+                open_report_exception: "open_report_exception";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly advance_gate: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            mode: z.ZodEnum<{
+                full: "full";
+                bugfix: "bugfix";
+                hotfix: "hotfix";
+            }>;
+            from_gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            to_gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            handoff_string: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            task_id: z.ZodString;
+            current_gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            allowed_tools: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly current_gate: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            mode: z.ZodEnum<{
+                full: "full";
+                bugfix: "bugfix";
+                hotfix: "hotfix";
+            }>;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            allowed_tools: z.ZodArray<z.ZodString>;
+            required_handoff_fields: z.ZodArray<z.ZodString>;
+            classification_pending: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly sign_off: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            signer: z.ZodEnum<{
+                den: "den";
+                mcp: "mcp";
+                system: "system";
+            }>;
+            evidence: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            signed: z.ZodLiteral<true>;
+            signer: z.ZodEnum<{
+                den: "den";
+                mcp: "mcp";
+                system: "system";
+            }>;
+            timestamp: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly submit_artifact: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            class: z.ZodEnum<{
+                skill: "skill";
+                adr: "adr";
+                persona: "persona";
+                role: "role";
+                diary: "diary";
+                working_report: "working_report";
+                handoff: "handoff";
+                memory_index: "memory_index";
+            }>;
+            path: z.ZodString;
+            content: z.ZodString;
+            frontmatter: z.ZodOptional<z.ZodUnknown>;
+            gate: z.ZodOptional<z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            written: z.ZodLiteral<true>;
+            path: z.ZodString;
+            line_count: z.ZodNumber;
+            cap: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>;
+    };
+    readonly verify_claim: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            claim_type: z.ZodEnum<{
+                custom: "custom";
+                tests_pass: "tests_pass";
+                build_succeeds: "build_succeeds";
+                lint_clean: "lint_clean";
+                no_orphan_skills: "no_orphan_skills";
+                owners_present: "owners_present";
+                vocab_valid: "vocab_valid";
+            }>;
+            args: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            verified: z.ZodBoolean;
+            evidence: z.ZodUnknown;
+            failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly report_exception: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            what_failed: z.ZodString;
+            breakdown: z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            exception_id: z.ZodString;
+            surfaced_to: z.ZodEnum<{
+                den: "den";
+                mcp: "mcp";
+                system: "system";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly get_artifact: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+                STRATEGIST: "STRATEGIST";
+                RESEARCHER: "RESEARCHER";
+                COPYWRITER: "COPYWRITER";
+                VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                REVIEWER: "REVIEWER";
+                RELEASE_GATE: "RELEASE_GATE";
+                INTERVIEWER: "INTERVIEWER";
+                DATA_ANALYST: "DATA_ANALYST";
+                MEDIATOR: "MEDIATOR";
+                DESIGNER: "DESIGNER";
+                LAYOUTER: "LAYOUTER";
+                DISCOVERY: "DISCOVERY";
+                PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                UX_DESIGNER: "UX_DESIGNER";
+                TECH_LEAD: "TECH_LEAD";
+            }>;
+            format: z.ZodDefault<z.ZodEnum<{
+                raw: "raw";
+                summary: "summary";
+            }>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            exists: z.ZodBoolean;
+            path: z.ZodOptional<z.ZodString>;
+            content: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly list_artifacts: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            artifacts: z.ZodArray<z.ZodObject<{
+                gate: z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>;
+                class: z.ZodEnum<{
+                    skill: "skill";
+                    adr: "adr";
+                    persona: "persona";
+                    role: "role";
+                    diary: "diary";
+                    working_report: "working_report";
+                    handoff: "handoff";
+                    memory_index: "memory_index";
+                }>;
+                path: z.ZodString;
+                line_count: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly audit_trail: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            events: z.ZodArray<z.ZodObject<{
+                timestamp: z.ZodString;
+                kind: z.ZodEnum<{
+                    classify_gate: "classify_gate";
+                    advance_gate: "advance_gate";
+                    sign_off: "sign_off";
+                    submit_artifact: "submit_artifact";
+                    request_decision: "request_decision";
+                    record_decision: "record_decision";
+                    report_exception: "report_exception";
+                    circuit_breaker_trip: "circuit_breaker_trip";
+                }>;
+                gate: z.ZodOptional<z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>>;
+                details: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly recent_decisions: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodOptional<z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>>;
+            since: z.ZodOptional<z.ZodString>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            decisions: z.ZodArray<z.ZodObject<{
+                adr_id: z.ZodString;
+                timestamp: z.ZodString;
+                question: z.ZodString;
+                chosen_option_id: z.ZodString;
+                signer: z.ZodEnum<{
+                    den: "den";
+                    mcp: "mcp";
+                    system: "system";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly regenerate_manifest: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>;
+            apply: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            agents_yaml_path: z.ZodString;
+            agents_md_path: z.ZodString;
+            diff: z.ZodString;
+            applied: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly run_drift_audit: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            orphan_skills: z.ZodArray<z.ZodString>;
+            phantom_skills: z.ZodArray<z.ZodString>;
+            yaml_skew: z.ZodArray<z.ZodObject<{
+                skill: z.ZodString;
+                field: z.ZodString;
+                yaml_value: z.ZodUnknown;
+                md_value: z.ZodUnknown;
+            }, z.core.$strip>>;
+            unowned: z.ZodArray<z.ZodString>;
+            missing_backlinks: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly audit_budget_compliance: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodUnion<readonly [z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>, z.ZodLiteral<"*">]>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            schema_violations: z.ZodArray<z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                file: z.ZodString;
+                file_type: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                declared_budget: z.ZodNumber;
+                schema_max: z.ZodNumber;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            budget_violations: z.ZodArray<z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                file: z.ZodString;
+                file_type: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                declared_budget: z.ZodNumber;
+                actual_lines: z.ZodNumber;
+                overage: z.ZodNumber;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            scanned: z.ZodObject<{
+                agents: z.ZodNumber;
+                skills: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    readonly audit_bilocale_parity: {
+        readonly input: z.ZodObject<{
+            domain: z.ZodUnion<readonly [z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>, z.ZodLiteral<"*">]>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            declared_mismatches: z.ZodArray<z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                id: z.ZodString;
+                file_type: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                ru_path: z.ZodString;
+                en_path: z.ZodString;
+                ru_declared: z.ZodNumber;
+                en_declared: z.ZodNumber;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            actual_mismatches: z.ZodArray<z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                id: z.ZodString;
+                file_type: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                ru_path: z.ZodString;
+                en_path: z.ZodString;
+                ru_actual: z.ZodNumber;
+                en_actual: z.ZodNumber;
+                diff: z.ZodNumber;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            orphans: z.ZodArray<z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                id: z.ZodString;
+                file_type: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                present_locale: z.ZodEnum<{
+                    ru: "ru";
+                    en: "en";
+                }>;
+                present_path: z.ZodString;
+                missing_locale: z.ZodEnum<{
+                    ru: "ru";
+                    en: "en";
+                }>;
+                message: z.ZodString;
+            }, z.core.$strip>>;
+            scanned: z.ZodObject<{
+                pairs: z.ZodNumber;
+                agents: z.ZodNumber;
+                skills: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    readonly aggregate_run_metrics: {
+        readonly input: z.ZodObject<{
+            min_runs: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            runs_in_ledger: z.ZodNumber;
+            runs_completed: z.ZodNumber;
+            min_runs: z.ZodNumber;
+            met_threshold: z.ZodBoolean;
+            per_workflow: z.ZodArray<z.ZodObject<{
+                mode: z.ZodEnum<{
+                    full: "full";
+                    bugfix: "bugfix";
+                    hotfix: "hotfix";
+                }>;
+                runs: z.ZodNumber;
+                completed: z.ZodNumber;
+                avg_dev_rollbacks: z.ZodNumber;
+                circuit_breaker_trips: z.ZodNumber;
+                total_exceptions: z.ZodNumber;
+            }, z.core.$strip>>;
+            per_agent: z.ZodArray<z.ZodObject<{
+                role: z.ZodString;
+                gate: z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                    STRATEGIST: "STRATEGIST";
+                    RESEARCHER: "RESEARCHER";
+                    COPYWRITER: "COPYWRITER";
+                    VISUAL_CONCEPT: "VISUAL_CONCEPT";
+                    REVIEWER: "REVIEWER";
+                    RELEASE_GATE: "RELEASE_GATE";
+                    INTERVIEWER: "INTERVIEWER";
+                    DATA_ANALYST: "DATA_ANALYST";
+                    MEDIATOR: "MEDIATOR";
+                    DESIGNER: "DESIGNER";
+                    LAYOUTER: "LAYOUTER";
+                    DISCOVERY: "DISCOVERY";
+                    PRODUCT_STRATEGIST: "PRODUCT_STRATEGIST";
+                    UX_DESIGNER: "UX_DESIGNER";
+                    TECH_LEAD: "TECH_LEAD";
+                }>;
+                runs_involved: z.ZodNumber;
+                reworked: z.ZodNumber;
+                first_try_rate: z.ZodNumber;
+                exceptions: z.ZodNumber;
+                classification_breakdown: z.ZodObject<{
+                    auto_resolve: z.ZodNumber;
+                    fork: z.ZodNumber;
+                    exception: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            per_skill: z.ZodArray<z.ZodObject<{
+                skill: z.ZodString;
+                invocations: z.ZodNumber;
+                runs_invoked_in: z.ZodNumber;
+                gates: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+            notes: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly propose_change: {
+        readonly input: z.ZodObject<{
+            target: z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                asset: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                name: z.ZodString;
+            }, z.core.$strip>;
+            change_kind: z.ZodEnum<{
+                edit_minor: "edit_minor";
+                add_asset: "add_asset";
+                destructive: "destructive";
+            }>;
+            rationale: z.ZodString;
+            evidence: z.ZodString;
+            threshold_met: z.ZodBoolean;
+            draft: z.ZodString;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                applied: "applied";
+                pending: "pending";
+                approved: "approved";
+                rejected: "rejected";
+                superseded: "superseded";
+            }>;
+            risk: z.ZodEnum<{
+                low: "low";
+                high: "high";
+                additive: "additive";
+            }>;
+            path: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly list_proposals: {
+        readonly input: z.ZodObject<{
+            status: z.ZodOptional<z.ZodEnum<{
+                applied: "applied";
+                pending: "pending";
+                approved: "approved";
+                rejected: "rejected";
+                superseded: "superseded";
+            }>>;
+            risk: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                high: "high";
+                additive: "additive";
+            }>>;
+            domain: z.ZodOptional<z.ZodEnum<{
+                development: "development";
+                content: "content";
+                analytics: "analytics";
+                product: "product";
+            }>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            proposals: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                created_at: z.ZodString;
+                status: z.ZodEnum<{
+                    applied: "applied";
+                    pending: "pending";
+                    approved: "approved";
+                    rejected: "rejected";
+                    superseded: "superseded";
+                }>;
+                risk: z.ZodEnum<{
+                    low: "low";
+                    high: "high";
+                    additive: "additive";
+                }>;
+                target: z.ZodObject<{
+                    domain: z.ZodEnum<{
+                        development: "development";
+                        content: "content";
+                        analytics: "analytics";
+                        product: "product";
+                    }>;
+                    asset: z.ZodEnum<{
+                        agent: "agent";
+                        skill: "skill";
+                    }>;
+                    name: z.ZodString;
+                }, z.core.$strip>;
+                change_kind: z.ZodEnum<{
+                    edit_minor: "edit_minor";
+                    add_asset: "add_asset";
+                    destructive: "destructive";
+                }>;
+                rationale: z.ZodString;
+                evidence: z.ZodString;
+                threshold_met: z.ZodBoolean;
+                draft: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly review_proposal: {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+            decision: z.ZodEnum<{
+                applied: "applied";
+                approve: "approve";
+                reject: "reject";
+            }>;
+            decided_by: z.ZodEnum<{
+                den: "den";
+                auditor_auto: "auditor_auto";
+            }>;
+            note: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            status: z.ZodEnum<{
+                applied: "applied";
+                pending: "pending";
+                approved: "approved";
+                rejected: "rejected";
+                superseded: "superseded";
+            }>;
+            risk: z.ZodEnum<{
+                low: "low";
+                high: "high";
+                additive: "additive";
+            }>;
+            decided_by: z.ZodString;
+            target: z.ZodObject<{
+                domain: z.ZodEnum<{
+                    development: "development";
+                    content: "content";
+                    analytics: "analytics";
+                    product: "product";
+                }>;
+                asset: z.ZodEnum<{
+                    agent: "agent";
+                    skill: "skill";
+                }>;
+                name: z.ZodString;
+            }, z.core.$strip>;
+            next_step: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly run_tests: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            duration_ms: z.ZodNumber;
+            failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly apply_diff: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            diff: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            files_changed: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly git_commit: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            message: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            paths: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            sha: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly check_lint: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            clean: z.ZodBoolean;
+            issues: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly build: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            succeeded: z.ZodBoolean;
+            errors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly dependency_supply_chain: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            vulnerabilities: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+            total_deps: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly docker_compose: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            command: z.ZodEnum<{
+                up: "up";
+                down: "down";
+                ps: "ps";
+                logs: "logs";
+            }>;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            exit_code: z.ZodNumber;
+            stdout: z.ZodString;
+            stderr: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly e2e_playwright: {
+        readonly input: z.ZodObject<{
+            task_id: z.ZodString;
+            spec: z.ZodOptional<z.ZodString>;
+            cwd: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            passed: z.ZodNumber;
+            failed: z.ZodNumber;
+            failures: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                message: z.ZodString;
+                evidence: z.ZodOptional<z.ZodUnknown>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+};
+export type ToolName = keyof typeof TOOL_REGISTRY;