code-ai-installer 2.5.0 → 4.0.0

package/dist/shared/tools.d.ts

@@ -0,0 +1,1655 @@
+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";
+        }>;
+        signs_off_at: z.ZodArray<z.ZodEnum<{
+            PM: "PM";
+            UX: "UX";
+            ARCH: "ARCH";
+            DEV: "DEV";
+            REV: "REV";
+            OPS: "OPS";
+            TEST: "TEST";
+            RG: "RG";
+        }>>;
+        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";
+    }>>;
+    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";
+        }>>;
+    }, 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";
+    }>;
+}, 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";
+        }>>>;
+        tech: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            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";
+    }>;
+    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<{
+        mcp: "mcp";
+        den: "den";
+        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";
+    }>;
+    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<{
+        mcp: "mcp";
+        den: "den";
+        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";
+    }>;
+    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";
+    }>;
+    to_gate: z.ZodEnum<{
+        PM: "PM";
+        UX: "UX";
+        ARCH: "ARCH";
+        DEV: "DEV";
+        REV: "REV";
+        OPS: "OPS";
+        TEST: "TEST";
+        RG: "RG";
+    }>;
+    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";
+    }>;
+    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";
+    }>;
+    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";
+    }>;
+    signer: z.ZodEnum<{
+        mcp: "mcp";
+        den: "den";
+        system: "system";
+    }>;
+    evidence: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const SignOffOutput: z.ZodObject<{
+    signed: z.ZodLiteral<true>;
+    signer: z.ZodEnum<{
+        mcp: "mcp";
+        den: "den";
+        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";
+    }>>;
+}, 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";
+    }>;
+    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<{
+        mcp: "mcp";
+        den: "den";
+        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";
+    }>;
+    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";
+        }>;
+        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";
+        }>>;
+        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<{
+            mcp: "mcp";
+            den: "den";
+            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 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";
+                }>;
+                signs_off_at: z.ZodArray<z.ZodEnum<{
+                    PM: "PM";
+                    UX: "UX";
+                    ARCH: "ARCH";
+                    DEV: "DEV";
+                    REV: "REV";
+                    OPS: "OPS";
+                    TEST: "TEST";
+                    RG: "RG";
+                }>>;
+                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";
+            }>>;
+            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";
+                }>>;
+            }, 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";
+            }>;
+        }, 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";
+                }>>>;
+                tech: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                    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";
+            }>;
+            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<{
+                mcp: "mcp";
+                den: "den";
+                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";
+            }>;
+            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<{
+                mcp: "mcp";
+                den: "den";
+                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";
+            }>;
+            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";
+            }>;
+            to_gate: z.ZodEnum<{
+                PM: "PM";
+                UX: "UX";
+                ARCH: "ARCH";
+                DEV: "DEV";
+                REV: "REV";
+                OPS: "OPS";
+                TEST: "TEST";
+                RG: "RG";
+            }>;
+            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";
+            }>;
+            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";
+            }>;
+            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";
+            }>;
+            signer: z.ZodEnum<{
+                mcp: "mcp";
+                den: "den";
+                system: "system";
+            }>;
+            evidence: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$strip>;
+        readonly output: z.ZodObject<{
+            signed: z.ZodLiteral<true>;
+            signer: z.ZodEnum<{
+                mcp: "mcp";
+                den: "den";
+                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";
+            }>>;
+        }, 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";
+            }>;
+            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<{
+                mcp: "mcp";
+                den: "den";
+                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";
+            }>;
+            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";
+                }>;
+                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";
+                }>>;
+                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<{
+                    mcp: "mcp";
+                    den: "den";
+                    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 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;