cc-codeconductor 0.5.0 → 1.0.0

package/dist/validation/schemas.d.ts

@@ -0,0 +1,3660 @@
+import { z } from 'zod';
+/**
+ * Council agent spec schema
+ */
+export declare const CouncilAgentSpecSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodString;
+    context: z.ZodEnum<["repo-readonly", "prompt-only"]>;
+    modelHint: z.ZodEnum<["strong-reasoning", "security-reasoning", "balanced", "practical-coding", "analytical", "adversarial"]>;
+    focus: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    role: string;
+    context: "repo-readonly" | "prompt-only";
+    modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+    focus: string[];
+}, {
+    id: string;
+    role: string;
+    context: "repo-readonly" | "prompt-only";
+    modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+    focus: string[];
+}>;
+/**
+ * Council spec schema
+ */
+export declare const CouncilSpecSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    outputContract: z.ZodString;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodString;
+        context: z.ZodEnum<["repo-readonly", "prompt-only"]>;
+        modelHint: z.ZodEnum<["strong-reasoning", "security-reasoning", "balanced", "practical-coding", "analytical", "adversarial"]>;
+        focus: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        role: string;
+        context: "repo-readonly" | "prompt-only";
+        modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+        focus: string[];
+    }, {
+        id: string;
+        role: string;
+        context: "repo-readonly" | "prompt-only";
+        modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+        focus: string[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    description: string;
+    outputContract: string;
+    agents: {
+        id: string;
+        role: string;
+        context: "repo-readonly" | "prompt-only";
+        modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+        focus: string[];
+    }[];
+}, {
+    name: string;
+    version: string;
+    description: string;
+    outputContract: string;
+    agents: {
+        id: string;
+        role: string;
+        context: "repo-readonly" | "prompt-only";
+        modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+        focus: string[];
+    }[];
+}>;
+/**
+ * Project profile schema
+ */
+export declare const ProjectProfileSchema: z.ZodObject<{
+    rootDir: z.ZodString;
+    languages: z.ZodArray<z.ZodString, "many">;
+    runtimes: z.ZodArray<z.ZodString, "many">;
+    packageManagers: z.ZodArray<z.ZodString, "many">;
+    frameworks: z.ZodArray<z.ZodString, "many">;
+    signals: z.ZodArray<z.ZodString, "many">;
+    confidence: z.ZodEnum<["low", "medium", "high"]>;
+}, "strip", z.ZodTypeAny, {
+    rootDir: string;
+    languages: string[];
+    runtimes: string[];
+    packageManagers: string[];
+    frameworks: string[];
+    signals: string[];
+    confidence: "low" | "medium" | "high";
+}, {
+    rootDir: string;
+    languages: string[];
+    runtimes: string[];
+    packageManagers: string[];
+    frameworks: string[];
+    signals: string[];
+    confidence: "low" | "medium" | "high";
+}>;
+/**
+ * Compile check config schema — validates the compileCheck section.
+ *
+ * `command` is a string from the analyzed repo. Verification only executes it
+ * when `--allow-compile-check` is set or the argv matches the compile allowlist.
+ */
+export declare const CompileCheckConfigSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    command: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    command?: string | undefined;
+    timeoutMs?: number | undefined;
+}, {
+    enabled: boolean;
+    command?: string | undefined;
+    timeoutMs?: number | undefined;
+}>;
+/**
+ * Loop config schema — validates the loop section for compile-fix iteration
+ */
+export declare const LoopConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxTokenBudget: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    compaction: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        historyFile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        historyFile?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        historyFile?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    maxIterations: number;
+    maxTokenBudget: number;
+    compaction?: {
+        enabled: boolean;
+        historyFile?: string | undefined;
+    } | undefined;
+}, {
+    enabled?: boolean | undefined;
+    maxIterations?: number | undefined;
+    maxTokenBudget?: number | undefined;
+    compaction?: {
+        enabled?: boolean | undefined;
+        historyFile?: string | undefined;
+    } | undefined;
+}>;
+/**
+ * CodeConductor config schema
+ */
+export declare const CodeConductorConfigSchema: z.ZodObject<{
+    version: z.ZodString;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        profile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        profile?: string | undefined;
+    }, {
+        name: string;
+        profile?: string | undefined;
+    }>;
+    defaults: z.ZodObject<{
+        target: z.ZodEnum<["opencode", "claude", "codex", "gemini", "cursor", "agy"]>;
+        overwrite: z.ZodBoolean;
+        locale: z.ZodDefault<z.ZodOptional<z.ZodEnum<["en", "es"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        overwrite: boolean;
+        locale: "en" | "es";
+    }, {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        overwrite: boolean;
+        locale?: "en" | "es" | undefined;
+    }>;
+    presets: z.ZodObject<{
+        council: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            version: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            version: string;
+            enabled: boolean;
+        }, {
+            version: string;
+            enabled: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        council: {
+            version: string;
+            enabled: boolean;
+        };
+    }, {
+        council: {
+            version: string;
+            enabled: boolean;
+        };
+    }>;
+    safety: z.ZodObject<{
+        destructiveCommands: z.ZodArray<z.ZodString, "many">;
+        secretPatterns: z.ZodArray<z.ZodString, "many">;
+        compileCheck: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            command: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        }, {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        destructiveCommands: string[];
+        secretPatterns: string[];
+        compileCheck?: {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }, {
+        destructiveCommands: string[];
+        secretPatterns: string[];
+        compileCheck?: {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }>;
+    loop: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        maxIterations: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        maxTokenBudget: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        compaction: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            historyFile: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            historyFile?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            historyFile?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        maxIterations: number;
+        maxTokenBudget: number;
+        compaction?: {
+            enabled: boolean;
+            historyFile?: string | undefined;
+        } | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        maxIterations?: number | undefined;
+        maxTokenBudget?: number | undefined;
+        compaction?: {
+            enabled?: boolean | undefined;
+            historyFile?: string | undefined;
+        } | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    project: {
+        name: string;
+        profile?: string | undefined;
+    };
+    defaults: {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        overwrite: boolean;
+        locale: "en" | "es";
+    };
+    presets: {
+        council: {
+            version: string;
+            enabled: boolean;
+        };
+    };
+    safety: {
+        destructiveCommands: string[];
+        secretPatterns: string[];
+        compileCheck?: {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    };
+    loop?: {
+        enabled: boolean;
+        maxIterations: number;
+        maxTokenBudget: number;
+        compaction?: {
+            enabled: boolean;
+            historyFile?: string | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    version: string;
+    project: {
+        name: string;
+        profile?: string | undefined;
+    };
+    defaults: {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        overwrite: boolean;
+        locale?: "en" | "es" | undefined;
+    };
+    presets: {
+        council: {
+            version: string;
+            enabled: boolean;
+        };
+    };
+    safety: {
+        destructiveCommands: string[];
+        secretPatterns: string[];
+        compileCheck?: {
+            enabled: boolean;
+            command?: string | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    };
+    loop?: {
+        enabled?: boolean | undefined;
+        maxIterations?: number | undefined;
+        maxTokenBudget?: number | undefined;
+        compaction?: {
+            enabled?: boolean | undefined;
+            historyFile?: string | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+/**
+ * Runner target schema
+ */
+export declare const RunnerTargetSchema: z.ZodEnum<["opencode", "claude", "codex", "gemini", "cursor", "agy", "all"]>;
+/**
+ * Install manifest schemas
+ */
+export declare const InstallStrategySchema: z.ZodEnum<["overwrite", "append", "merge-json", "merge-managed", "skip"]>;
+export declare const ManifestEntrySchema: z.ZodObject<{
+    src: z.ZodString;
+    dest: z.ZodString;
+    strategy: z.ZodEnum<["overwrite", "append", "merge-json", "merge-managed", "skip"]>;
+    globalStrategy: z.ZodOptional<z.ZodEnum<["overwrite", "append", "merge-json", "merge-managed", "skip"]>>;
+    template: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    src: string;
+    dest: string;
+    strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+    globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+    template?: boolean | undefined;
+}, {
+    src: string;
+    dest: string;
+    strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+    globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+    template?: boolean | undefined;
+}>;
+export declare const InstallManifestSchema: z.ZodObject<{
+    target: z.ZodEnum<["opencode", "claude", "codex", "gemini", "cursor", "agy"]>;
+    entries: z.ZodArray<z.ZodObject<{
+        src: z.ZodString;
+        dest: z.ZodString;
+        strategy: z.ZodEnum<["overwrite", "append", "merge-json", "merge-managed", "skip"]>;
+        globalStrategy: z.ZodOptional<z.ZodEnum<["overwrite", "append", "merge-json", "merge-managed", "skip"]>>;
+        template: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        src: string;
+        dest: string;
+        strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+        globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+        template?: boolean | undefined;
+    }, {
+        src: string;
+        dest: string;
+        strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+        globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+        template?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        src: string;
+        dest: string;
+        strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+        globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+        template?: boolean | undefined;
+    }[];
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+}, {
+    entries: {
+        src: string;
+        dest: string;
+        strategy: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip";
+        globalStrategy?: "overwrite" | "append" | "merge-json" | "merge-managed" | "skip" | undefined;
+        template?: boolean | undefined;
+    }[];
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+}>;
+/**
+ * Tool provider names schema — maps base tool names to provider-specific names
+ */
+export declare const ToolProviderNamesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export declare const PermissionProviderNamesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+/**
+ * Model config schema — defines model names per provider per agent role
+ */
+export declare const ModelConfigSchema: z.ZodObject<{
+    target: z.ZodEnum<["opencode", "claude", "codex", "gemini", "cursor", "agy"]>;
+    agents: z.ZodRecord<z.ZodString, z.ZodObject<{
+        claude: z.ZodOptional<z.ZodString>;
+        opencode: z.ZodOptional<z.ZodString>;
+        codex: z.ZodOptional<z.ZodString>;
+        gemini: z.ZodOptional<z.ZodString>;
+        cursor: z.ZodOptional<z.ZodString>;
+        agy: z.ZodOptional<z.ZodString>;
+        grok: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        opencode?: string | undefined;
+        claude?: string | undefined;
+        codex?: string | undefined;
+        gemini?: string | undefined;
+        cursor?: string | undefined;
+        agy?: string | undefined;
+        grok?: string | undefined;
+    }, {
+        opencode?: string | undefined;
+        claude?: string | undefined;
+        codex?: string | undefined;
+        gemini?: string | undefined;
+        cursor?: string | undefined;
+        agy?: string | undefined;
+        grok?: string | undefined;
+    }>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    permissions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    agents: Record<string, {
+        opencode?: string | undefined;
+        claude?: string | undefined;
+        codex?: string | undefined;
+        gemini?: string | undefined;
+        cursor?: string | undefined;
+        agy?: string | undefined;
+        grok?: string | undefined;
+    }>;
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+    tools?: Record<string, Record<string, string>> | undefined;
+    permissions?: Record<string, string> | undefined;
+}, {
+    agents: Record<string, {
+        opencode?: string | undefined;
+        claude?: string | undefined;
+        codex?: string | undefined;
+        gemini?: string | undefined;
+        cursor?: string | undefined;
+        agy?: string | undefined;
+        grok?: string | undefined;
+    }>;
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+    tools?: Record<string, Record<string, string>> | undefined;
+    permissions?: Record<string, string> | undefined;
+}>;
+export type ModelConfig = z.infer<typeof ModelConfigSchema>;
+/**
+ * Type exports
+ */
+export type InstallStrategy = z.infer<typeof InstallStrategySchema>;
+export type ManifestEntry = z.infer<typeof ManifestEntrySchema>;
+export type InstallManifest = z.infer<typeof InstallManifestSchema>;
+export type CouncilAgentSpecInput = z.infer<typeof CouncilAgentSpecSchema>;
+export type CouncilSpecInput = z.infer<typeof CouncilSpecSchema>;
+export type ProjectProfileInput = z.infer<typeof ProjectProfileSchema>;
+export type CodeConductorConfigInput = z.infer<typeof CodeConductorConfigSchema>;
+export type CompileCheckConfigInput = z.infer<typeof CompileCheckConfigSchema>;
+export type LoopConfigInput = z.infer<typeof LoopConfigSchema>;
+export type RunnerTargetInput = z.infer<typeof RunnerTargetSchema>;
+/**
+ * Validate council spec
+ */
+export declare function validateCouncilSpec(data: unknown): CouncilSpecInput;
+/**
+ * Validate project profile
+ */
+export declare function validateProjectProfile(data: unknown): ProjectProfileInput;
+/**
+ * Validate config
+ */
+export declare function validateConfig(data: unknown): CodeConductorConfigInput;
+/**
+ * Validate runner target
+ */
+export declare function validateRunnerTarget(data: unknown): RunnerTargetInput;
+/**
+ * Validate model configuration
+ */
+export declare function validateModelConfig(data: unknown): ModelConfig;
+/**
+ * Contract target enum
+ */
+export declare const ContractTargetSchema: z.ZodEnum<["claude", "opencode", "codex", "gemini", "cursor", "agy"]>;
+/**
+ * Contract format schema — a target with optional render options
+ */
+export declare const ContractFormatSchema: z.ZodObject<{
+    target: z.ZodEnum<["claude", "opencode", "codex", "gemini", "cursor", "agy"]>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+    options?: Record<string, unknown> | undefined;
+}, {
+    target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+    options?: Record<string, unknown> | undefined;
+}>;
+/**
+ * Agent contract schema — provider-agnostic contract definition
+ */
+export declare const AgentContractSchema: z.ZodObject<{
+    council: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        description: z.ZodString;
+        outputContract: z.ZodString;
+        agents: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodString;
+            context: z.ZodEnum<["repo-readonly", "prompt-only"]>;
+            modelHint: z.ZodEnum<["strong-reasoning", "security-reasoning", "balanced", "practical-coding", "analytical", "adversarial"]>;
+            focus: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }, {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        version: string;
+        description: string;
+        outputContract: string;
+        agents: {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }[];
+    }, {
+        name: string;
+        version: string;
+        description: string;
+        outputContract: string;
+        agents: {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }[];
+    }>;
+    targets: z.ZodArray<z.ZodObject<{
+        target: z.ZodEnum<["claude", "opencode", "codex", "gemini", "cursor", "agy"]>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        options?: Record<string, unknown> | undefined;
+    }, {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        options?: Record<string, unknown> | undefined;
+    }>, "many">;
+    contractVersion: z.ZodString;
+    renderHints: z.ZodOptional<z.ZodRecord<z.ZodEnum<["claude", "opencode", "codex", "gemini", "cursor", "agy"]>, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    council: {
+        name: string;
+        version: string;
+        description: string;
+        outputContract: string;
+        agents: {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }[];
+    };
+    targets: {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        options?: Record<string, unknown> | undefined;
+    }[];
+    contractVersion: string;
+    renderHints?: Partial<Record<"opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy", Record<string, unknown>>> | undefined;
+}, {
+    council: {
+        name: string;
+        version: string;
+        description: string;
+        outputContract: string;
+        agents: {
+            id: string;
+            role: string;
+            context: "repo-readonly" | "prompt-only";
+            modelHint: "strong-reasoning" | "security-reasoning" | "balanced" | "practical-coding" | "analytical" | "adversarial";
+            focus: string[];
+        }[];
+    };
+    targets: {
+        target: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy";
+        options?: Record<string, unknown> | undefined;
+    }[];
+    contractVersion: string;
+    renderHints?: Partial<Record<"opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy", Record<string, unknown>>> | undefined;
+}>;
+/**
+ * Council finding schema — a single review observation
+ */
+export declare const CouncilFindingSchema: z.ZodObject<{
+    category: z.ZodString;
+    severity: z.ZodEnum<["info", "warning", "critical"]>;
+    message: z.ZodString;
+    agentId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    category: string;
+    severity: "info" | "warning" | "critical";
+    agentId: string;
+}, {
+    message: string;
+    category: string;
+    severity: "info" | "warning" | "critical";
+    agentId: string;
+}>;
+/**
+ * Council verdict input schema — verdict from a single reviewer
+ */
+export declare const CouncilVerdictInputSchema: z.ZodObject<{
+    agentId: z.ZodEffects<z.ZodString, string, string>;
+    agentRole: z.ZodString;
+    status: z.ZodEnum<["APPROVED", "REJECTED", "ABSTAIN"]>;
+    securityVeto: z.ZodBoolean;
+    complianceVeto: z.ZodOptional<z.ZodBoolean>;
+    confidence: z.ZodOptional<z.ZodNumber>;
+    findings: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        message: z.ZodString;
+        agentId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }, {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }>, "many">;
+    summary: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    status: "APPROVED" | "REJECTED" | "ABSTAIN";
+    agentId: string;
+    agentRole: string;
+    securityVeto: boolean;
+    findings: {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }[];
+    summary: string;
+    confidence?: number | undefined;
+    complianceVeto?: boolean | undefined;
+}, {
+    status: "APPROVED" | "REJECTED" | "ABSTAIN";
+    agentId: string;
+    agentRole: string;
+    securityVeto: boolean;
+    findings: {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }[];
+    summary: string;
+    confidence?: number | undefined;
+    complianceVeto?: boolean | undefined;
+}>;
+/**
+ * Consensus config schema
+ */
+export declare const ConsensusConfigSchema: z.ZodEffects<z.ZodObject<{
+    algorithm: z.ZodEnum<["majority", "unanimous"]>;
+    allowSecurityVeto: z.ZodBoolean;
+    allowComplianceVeto: z.ZodOptional<z.ZodBoolean>;
+    expectedAgentIds: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">, string[], string[]>>;
+}, "strip", z.ZodTypeAny, {
+    algorithm: "majority" | "unanimous";
+    allowSecurityVeto: boolean;
+    allowComplianceVeto?: boolean | undefined;
+    expectedAgentIds?: string[] | undefined;
+}, {
+    algorithm: "majority" | "unanimous";
+    allowSecurityVeto: boolean;
+    allowComplianceVeto?: boolean | undefined;
+    expectedAgentIds?: string[] | undefined;
+}>, {
+    algorithm: "majority" | "unanimous";
+    allowSecurityVeto: boolean;
+    allowComplianceVeto?: boolean | undefined;
+    expectedAgentIds?: string[] | undefined;
+}, {
+    algorithm: "majority" | "unanimous";
+    allowSecurityVeto: boolean;
+    allowComplianceVeto?: boolean | undefined;
+    expectedAgentIds?: string[] | undefined;
+}>;
+/**
+ * Council verdict schema — the final output of the consensus engine
+ */
+export declare const CouncilVerdictSchema: z.ZodObject<{
+    status: z.ZodEnum<["APPROVED", "REJECTED", "ESCALATED"]>;
+    totalAgents: z.ZodNumber;
+    approvedCount: z.ZodNumber;
+    rejectedCount: z.ZodNumber;
+    abstainedCount: z.ZodNumber;
+    vetoApplied: z.ZodBoolean;
+    complianceVetoApplied: z.ZodOptional<z.ZodBoolean>;
+    vetoByAgentId: z.ZodOptional<z.ZodString>;
+    averageConfidence: z.ZodOptional<z.ZodNumber>;
+    findings: z.ZodArray<z.ZodObject<{
+        category: z.ZodString;
+        severity: z.ZodEnum<["info", "warning", "critical"]>;
+        message: z.ZodString;
+        agentId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }, {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }>, "many">;
+    summary: z.ZodString;
+    individualVerdicts: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodEffects<z.ZodString, string, string>;
+        agentRole: z.ZodString;
+        status: z.ZodEnum<["APPROVED", "REJECTED", "ABSTAIN"]>;
+        securityVeto: z.ZodBoolean;
+        complianceVeto: z.ZodOptional<z.ZodBoolean>;
+        confidence: z.ZodOptional<z.ZodNumber>;
+        findings: z.ZodArray<z.ZodObject<{
+            category: z.ZodString;
+            severity: z.ZodEnum<["info", "warning", "critical"]>;
+            message: z.ZodString;
+            agentId: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }, {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }>, "many">;
+        summary: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        status: "APPROVED" | "REJECTED" | "ABSTAIN";
+        agentId: string;
+        agentRole: string;
+        securityVeto: boolean;
+        findings: {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }[];
+        summary: string;
+        confidence?: number | undefined;
+        complianceVeto?: boolean | undefined;
+    }, {
+        status: "APPROVED" | "REJECTED" | "ABSTAIN";
+        agentId: string;
+        agentRole: string;
+        securityVeto: boolean;
+        findings: {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }[];
+        summary: string;
+        confidence?: number | undefined;
+        complianceVeto?: boolean | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    status: "APPROVED" | "REJECTED" | "ESCALATED";
+    findings: {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }[];
+    summary: string;
+    totalAgents: number;
+    approvedCount: number;
+    rejectedCount: number;
+    abstainedCount: number;
+    vetoApplied: boolean;
+    individualVerdicts: {
+        status: "APPROVED" | "REJECTED" | "ABSTAIN";
+        agentId: string;
+        agentRole: string;
+        securityVeto: boolean;
+        findings: {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }[];
+        summary: string;
+        confidence?: number | undefined;
+        complianceVeto?: boolean | undefined;
+    }[];
+    complianceVetoApplied?: boolean | undefined;
+    vetoByAgentId?: string | undefined;
+    averageConfidence?: number | undefined;
+}, {
+    status: "APPROVED" | "REJECTED" | "ESCALATED";
+    findings: {
+        message: string;
+        category: string;
+        severity: "info" | "warning" | "critical";
+        agentId: string;
+    }[];
+    summary: string;
+    totalAgents: number;
+    approvedCount: number;
+    rejectedCount: number;
+    abstainedCount: number;
+    vetoApplied: boolean;
+    individualVerdicts: {
+        status: "APPROVED" | "REJECTED" | "ABSTAIN";
+        agentId: string;
+        agentRole: string;
+        securityVeto: boolean;
+        findings: {
+            message: string;
+            category: string;
+            severity: "info" | "warning" | "critical";
+            agentId: string;
+        }[];
+        summary: string;
+        confidence?: number | undefined;
+        complianceVeto?: boolean | undefined;
+    }[];
+    complianceVetoApplied?: boolean | undefined;
+    vetoByAgentId?: string | undefined;
+    averageConfidence?: number | undefined;
+}>;
+/**
+ * Claude agent file schema — validates a single Claude-generated agent markdown file
+ */
+export declare const ClaudeAgentFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    overwrite: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+}, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+}>;
+/**
+ * OpenCode agent file schema — validates a single OpenCode-generated agent markdown file
+ */
+export declare const OpenCodeAgentFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    overwrite: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+}, {
+    path: string;
+    overwrite: boolean;
+    content: string;
+}>;
+/**
+ * Stack frame schema — a single frame from a Sentry stack trace
+ */
+export declare const SentryStackFrameSchema: z.ZodObject<{
+    filename: z.ZodString;
+    function: z.ZodString;
+    lineNo: z.ZodNumber;
+    colNo: z.ZodOptional<z.ZodNumber>;
+    context: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    function: string;
+    context: string[];
+    filename: string;
+    lineNo: number;
+    colNo?: number | undefined;
+}, {
+    function: string;
+    context: string[];
+    filename: string;
+    lineNo: number;
+    colNo?: number | undefined;
+}>;
+/**
+ * Sentry webhook payload schema — validates the issue context from Sentry webhooks
+ */
+export declare const SentryWebhookSchema: z.ZodObject<{
+    issueId: z.ZodString;
+    title: z.ZodString;
+    culprit: z.ZodString;
+    filename: z.ZodOptional<z.ZodString>;
+    stackTrace: z.ZodArray<z.ZodObject<{
+        filename: z.ZodString;
+        function: z.ZodString;
+        lineNo: z.ZodNumber;
+        colNo: z.ZodOptional<z.ZodNumber>;
+        context: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        function: string;
+        context: string[];
+        filename: string;
+        lineNo: number;
+        colNo?: number | undefined;
+    }, {
+        function: string;
+        context: string[];
+        filename: string;
+        lineNo: number;
+        colNo?: number | undefined;
+    }>, "many">;
+    environment: z.ZodOptional<z.ZodString>;
+    release: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    issueId: string;
+    title: string;
+    culprit: string;
+    stackTrace: {
+        function: string;
+        context: string[];
+        filename: string;
+        lineNo: number;
+        colNo?: number | undefined;
+    }[];
+    filename?: string | undefined;
+    environment?: string | undefined;
+    release?: string | undefined;
+}, {
+    issueId: string;
+    title: string;
+    culprit: string;
+    stackTrace: {
+        function: string;
+        context: string[];
+        filename: string;
+        lineNo: number;
+        colNo?: number | undefined;
+    }[];
+    filename?: string | undefined;
+    environment?: string | undefined;
+    release?: string | undefined;
+}>;
+export type SentryWebhookInput = z.infer<typeof SentryWebhookSchema>;
+/**
+ * Memory pointer schema — a lightweight reference to an Engram observation
+ */
+export declare const MemoryPointerSchema: z.ZodObject<{
+    topic_key: z.ZodString;
+    id: z.ZodNumber;
+    file: z.ZodString;
+    summary: z.ZodString;
+    timestamp: z.ZodString;
+    tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    summary: string;
+    topic_key: string;
+    file: string;
+    timestamp: string;
+    tags: string[];
+}, {
+    id: number;
+    summary: string;
+    topic_key: string;
+    file: string;
+    timestamp: string;
+    tags?: string[] | undefined;
+}>;
+/**
+ * Memory index schema — the persistent pointer layer of the 3-layer memory arch
+ */
+export declare const MemoryIndexSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    pointers: z.ZodArray<z.ZodObject<{
+        topic_key: z.ZodString;
+        id: z.ZodNumber;
+        file: z.ZodString;
+        summary: z.ZodString;
+        timestamp: z.ZodString;
+        tags: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        id: number;
+        summary: string;
+        topic_key: string;
+        file: string;
+        timestamp: string;
+        tags: string[];
+    }, {
+        id: number;
+        summary: string;
+        topic_key: string;
+        file: string;
+        timestamp: string;
+        tags?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    pointers: {
+        id: number;
+        summary: string;
+        topic_key: string;
+        file: string;
+        timestamp: string;
+        tags: string[];
+    }[];
+}, {
+    version: 1;
+    pointers: {
+        id: number;
+        summary: string;
+        topic_key: string;
+        file: string;
+        timestamp: string;
+        tags?: string[] | undefined;
+    }[];
+}>;
+/**
+ * Goal task schema — a single task in a goal graph
+ */
+export declare const GoalTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    type: z.ZodEnum<["feature", "fix", "refactor", "test", "docs"]>;
+    risk: z.ZodEnum<["low", "medium", "high"]>;
+    status: z.ZodEnum<["pending", "in-progress", "done", "blocked"]>;
+    depends_on: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    acceptance_criteria: z.ZodArray<z.ZodString, "many">;
+    blocked_reason: z.ZodOptional<z.ZodString>;
+    context_scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["isolated", "continuation", "full"]>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "pending" | "in-progress" | "done" | "blocked";
+    type: "feature" | "fix" | "refactor" | "test" | "docs";
+    title: string;
+    risk: "low" | "medium" | "high";
+    depends_on: string[];
+    acceptance_criteria: string[];
+    context_scope: "isolated" | "continuation" | "full";
+    blocked_reason?: string | undefined;
+}, {
+    id: string;
+    status: "pending" | "in-progress" | "done" | "blocked";
+    type: "feature" | "fix" | "refactor" | "test" | "docs";
+    title: string;
+    risk: "low" | "medium" | "high";
+    acceptance_criteria: string[];
+    depends_on?: string[] | undefined;
+    blocked_reason?: string | undefined;
+    context_scope?: "isolated" | "continuation" | "full" | undefined;
+}>;
+/**
+ * Goal graph schema — a complete goal with task dependencies
+ */
+export declare const GoalGraphSchema: z.ZodObject<{
+    objective: z.ZodString;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        type: z.ZodEnum<["feature", "fix", "refactor", "test", "docs"]>;
+        risk: z.ZodEnum<["low", "medium", "high"]>;
+        status: z.ZodEnum<["pending", "in-progress", "done", "blocked"]>;
+        depends_on: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        acceptance_criteria: z.ZodArray<z.ZodString, "many">;
+        blocked_reason: z.ZodOptional<z.ZodString>;
+        context_scope: z.ZodDefault<z.ZodOptional<z.ZodEnum<["isolated", "continuation", "full"]>>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "pending" | "in-progress" | "done" | "blocked";
+        type: "feature" | "fix" | "refactor" | "test" | "docs";
+        title: string;
+        risk: "low" | "medium" | "high";
+        depends_on: string[];
+        acceptance_criteria: string[];
+        context_scope: "isolated" | "continuation" | "full";
+        blocked_reason?: string | undefined;
+    }, {
+        id: string;
+        status: "pending" | "in-progress" | "done" | "blocked";
+        type: "feature" | "fix" | "refactor" | "test" | "docs";
+        title: string;
+        risk: "low" | "medium" | "high";
+        acceptance_criteria: string[];
+        depends_on?: string[] | undefined;
+        blocked_reason?: string | undefined;
+        context_scope?: "isolated" | "continuation" | "full" | undefined;
+    }>, "many">;
+    created_at: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    objective: string;
+    tasks: {
+        id: string;
+        status: "pending" | "in-progress" | "done" | "blocked";
+        type: "feature" | "fix" | "refactor" | "test" | "docs";
+        title: string;
+        risk: "low" | "medium" | "high";
+        depends_on: string[];
+        acceptance_criteria: string[];
+        context_scope: "isolated" | "continuation" | "full";
+        blocked_reason?: string | undefined;
+    }[];
+    created_at: string;
+}, {
+    objective: string;
+    tasks: {
+        id: string;
+        status: "pending" | "in-progress" | "done" | "blocked";
+        type: "feature" | "fix" | "refactor" | "test" | "docs";
+        title: string;
+        risk: "low" | "medium" | "high";
+        acceptance_criteria: string[];
+        depends_on?: string[] | undefined;
+        blocked_reason?: string | undefined;
+        context_scope?: "isolated" | "continuation" | "full" | undefined;
+    }[];
+    created_at: string;
+}>;
+export declare const ConfidenceLevelSchema: z.ZodEnum<["low", "medium", "high"]>;
+export declare const ProductNodeTypeSchema: z.ZodEnum<["product", "domain", "capability", "requirement", "decision", "component", "flow", "contract", "metric", "risk", "task", "evidence"]>;
+export declare const GraphRelationSchema: z.ZodEnum<["implements", "depends_on", "documents", "affects", "evidences", "blocks", "contains"]>;
+export declare const KnowledgeEntitySchema: z.ZodObject<{
+    type: z.ZodEnum<["product", "domain", "capability", "requirement", "decision", "component", "flow", "contract", "metric", "risk", "task", "evidence"]>;
+    id: z.ZodString;
+    name: z.ZodString;
+    source: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodEnum<["low", "medium", "high"]>;
+    relations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        targetId: z.ZodString;
+        relation: z.ZodEnum<["implements", "depends_on", "documents", "affects", "evidences", "blocks", "contains"]>;
+    }, "strip", z.ZodTypeAny, {
+        targetId: string;
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    }, {
+        targetId: string;
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    }>, "many">>;
+    data: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+    name: string;
+    confidence: "low" | "medium" | "high";
+    source: string;
+    relations: {
+        targetId: string;
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    }[];
+    data: Record<string, unknown>;
+    version?: string | undefined;
+}, {
+    id: string;
+    type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+    name: string;
+    confidence: "low" | "medium" | "high";
+    source: string;
+    version?: string | undefined;
+    relations?: {
+        targetId: string;
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    }[] | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export declare const DecisionSchema: z.ZodObject<{
+    id: z.ZodString;
+    context: z.ZodString;
+    alternatives: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    chosenOption: z.ZodString;
+    rationale: z.ZodString;
+    consequences: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    date: z.ZodString;
+    linkedTasks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    linkedComponents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    context: string;
+    date: string;
+    alternatives: string[];
+    chosenOption: string;
+    rationale: string;
+    consequences: string[];
+    linkedTasks: string[];
+    linkedComponents: string[];
+    source?: string | undefined;
+}, {
+    id: string;
+    context: string;
+    date: string;
+    chosenOption: string;
+    rationale: string;
+    source?: string | undefined;
+    alternatives?: string[] | undefined;
+    consequences?: string[] | undefined;
+    linkedTasks?: string[] | undefined;
+    linkedComponents?: string[] | undefined;
+}>;
+export declare const EvidenceSchema: z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    type: z.ZodString;
+    timestamp: z.ZodString;
+    relatedTask: z.ZodOptional<z.ZodString>;
+    relatedDecision: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodNumber;
+    checksum: z.ZodOptional<z.ZodString>;
+    summary: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: string;
+    confidence: number;
+    timestamp: string;
+    source: string;
+    summary?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    relatedTask?: string | undefined;
+    relatedDecision?: string | undefined;
+    checksum?: string | undefined;
+}, {
+    id: string;
+    type: string;
+    confidence: number;
+    timestamp: string;
+    source: string;
+    summary?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+    relatedTask?: string | undefined;
+    relatedDecision?: string | undefined;
+    checksum?: string | undefined;
+}>;
+export declare const CanonicalTaskCardStatusSchema: z.ZodEnum<["draft", "ready", "in-progress", "review", "done", "blocked"]>;
+export declare const CanonicalTaskCardSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    objective: z.ZodString;
+    context: z.ZodString;
+    acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    risk: z.ZodEnum<["low", "medium", "high"]>;
+    targetFiles: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    agentType: z.ZodString;
+    evidenceRequired: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    status: z.ZodEnum<["draft", "ready", "in-progress", "review", "done", "blocked"]>;
+    type: z.ZodOptional<z.ZodEnum<["feature", "fix", "refactor", "review", "docs", "test"]>>;
+    linkedCapabilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    context: string;
+    status: "in-progress" | "done" | "blocked" | "draft" | "ready" | "review";
+    title: string;
+    risk: "low" | "medium" | "high";
+    objective: string;
+    acceptanceCriteria: string[];
+    dependencies: string[];
+    constraints: string[];
+    targetFiles: string[];
+    agentType: string;
+    evidenceRequired: string[];
+    linkedCapabilities: string[];
+    type?: "feature" | "fix" | "refactor" | "test" | "docs" | "review" | undefined;
+}, {
+    id: string;
+    context: string;
+    status: "in-progress" | "done" | "blocked" | "draft" | "ready" | "review";
+    title: string;
+    risk: "low" | "medium" | "high";
+    objective: string;
+    acceptanceCriteria: string[];
+    agentType: string;
+    type?: "feature" | "fix" | "refactor" | "test" | "docs" | "review" | undefined;
+    dependencies?: string[] | undefined;
+    constraints?: string[] | undefined;
+    targetFiles?: string[] | undefined;
+    evidenceRequired?: string[] | undefined;
+    linkedCapabilities?: string[] | undefined;
+}>;
+export declare const ProductGraphNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["product", "domain", "capability", "requirement", "decision", "component", "flow", "contract", "metric", "risk", "task", "evidence"]>;
+    name: z.ZodString;
+    data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    source: z.ZodOptional<z.ZodString>;
+    confidence: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+    name: string;
+    data: Record<string, unknown>;
+    version?: string | undefined;
+    confidence?: "low" | "medium" | "high" | undefined;
+    source?: string | undefined;
+}, {
+    id: string;
+    type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+    name: string;
+    version?: string | undefined;
+    confidence?: "low" | "medium" | "high" | undefined;
+    source?: string | undefined;
+    data?: Record<string, unknown> | undefined;
+}>;
+export declare const ProductGraphEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    relation: z.ZodEnum<["implements", "depends_on", "documents", "affects", "evidences", "blocks", "contains"]>;
+}, "strip", z.ZodTypeAny, {
+    relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    from: string;
+    to: string;
+}, {
+    relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+    from: string;
+    to: string;
+}>;
+export declare const ProductGraphSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    productId: z.ZodString;
+    productName: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["product", "domain", "capability", "requirement", "decision", "component", "flow", "contract", "metric", "risk", "task", "evidence"]>;
+        name: z.ZodString;
+        data: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        source: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+        version: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+        name: string;
+        data: Record<string, unknown>;
+        version?: string | undefined;
+        confidence?: "low" | "medium" | "high" | undefined;
+        source?: string | undefined;
+    }, {
+        id: string;
+        type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+        name: string;
+        version?: string | undefined;
+        confidence?: "low" | "medium" | "high" | undefined;
+        source?: string | undefined;
+        data?: Record<string, unknown> | undefined;
+    }>, "many">;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        relation: z.ZodEnum<["implements", "depends_on", "documents", "affects", "evidences", "blocks", "contains"]>;
+    }, "strip", z.ZodTypeAny, {
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+        from: string;
+        to: string;
+    }, {
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+        from: string;
+        to: string;
+    }>, "many">;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    productId: string;
+    productName: string;
+    nodes: {
+        id: string;
+        type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+        name: string;
+        data: Record<string, unknown>;
+        version?: string | undefined;
+        confidence?: "low" | "medium" | "high" | undefined;
+        source?: string | undefined;
+    }[];
+    edges: {
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+        from: string;
+        to: string;
+    }[];
+    updatedAt: string;
+}, {
+    version: 1;
+    productId: string;
+    productName: string;
+    nodes: {
+        id: string;
+        type: "risk" | "product" | "domain" | "capability" | "requirement" | "decision" | "component" | "flow" | "contract" | "metric" | "task" | "evidence";
+        name: string;
+        version?: string | undefined;
+        confidence?: "low" | "medium" | "high" | undefined;
+        source?: string | undefined;
+        data?: Record<string, unknown> | undefined;
+    }[];
+    edges: {
+        relation: "depends_on" | "implements" | "documents" | "affects" | "evidences" | "blocks" | "contains";
+        from: string;
+        to: string;
+    }[];
+    updatedAt: string;
+}>;
+export declare const ProductMetaSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    graphVersion: z.ZodString;
+    lastIngestAt: z.ZodOptional<z.ZodString>;
+    sourceHashes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    graphVersion: string;
+    sourceHashes: Record<string, string>;
+    lastIngestAt?: string | undefined;
+}, {
+    version: 1;
+    graphVersion: string;
+    lastIngestAt?: string | undefined;
+    sourceHashes?: Record<string, string> | undefined;
+}>;
+export declare const ProductEventTypeSchema: z.ZodEnum<["task.started", "task.completed", "decision.recorded", "evidence.added", "ingest.completed", "goal.updated", "blocker.detected", "verification.completed", "feedback.processed"]>;
+export declare const ProductEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["task.started", "task.completed", "decision.recorded", "evidence.added", "ingest.completed", "goal.updated", "blocker.detected", "verification.completed", "feedback.processed"]>;
+    timestamp: z.ZodString;
+    payload: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "task.started" | "task.completed" | "decision.recorded" | "evidence.added" | "ingest.completed" | "goal.updated" | "blocker.detected" | "verification.completed" | "feedback.processed";
+    timestamp: string;
+    payload: Record<string, unknown>;
+}, {
+    id: string;
+    type: "task.started" | "task.completed" | "decision.recorded" | "evidence.added" | "ingest.completed" | "goal.updated" | "blocker.detected" | "verification.completed" | "feedback.processed";
+    timestamp: string;
+    payload?: Record<string, unknown> | undefined;
+}>;
+export declare const OperationalStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    activeAgents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    activeTaskIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    blockers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        reason: z.ZodString;
+        since: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        taskId: string;
+        reason: string;
+        since: string;
+    }, {
+        taskId: string;
+        reason: string;
+        since: string;
+    }>, "many">>;
+    sprintFocus: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    updatedAt: string;
+    activeAgents: string[];
+    activeTaskIds: string[];
+    blockers: {
+        taskId: string;
+        reason: string;
+        since: string;
+    }[];
+    sprintFocus?: string | undefined;
+}, {
+    version: 1;
+    updatedAt: string;
+    activeAgents?: string[] | undefined;
+    activeTaskIds?: string[] | undefined;
+    blockers?: {
+        taskId: string;
+        reason: string;
+        since: string;
+    }[] | undefined;
+    sprintFocus?: string | undefined;
+}>;
+export declare const StrategicMemorySchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    kpis: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        target: z.ZodString;
+        current: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        target: string;
+        current?: string | undefined;
+    }, {
+        name: string;
+        target: string;
+        current?: string | undefined;
+    }>, "many">>;
+    quarterlyFocus: z.ZodOptional<z.ZodString>;
+    tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    updatedAt: string;
+    kpis: {
+        name: string;
+        target: string;
+        current?: string | undefined;
+    }[];
+    tradeoffs: string[];
+    quarterlyFocus?: string | undefined;
+}, {
+    version: 1;
+    updatedAt: string;
+    kpis?: {
+        name: string;
+        target: string;
+        current?: string | undefined;
+    }[] | undefined;
+    quarterlyFocus?: string | undefined;
+    tradeoffs?: string[] | undefined;
+}>;
+export declare const ImpactReportSchema: z.ZodObject<{
+    target: z.ZodString;
+    brokenEndpoints: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    brokenContracts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    affectedTests: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    affectedFlows: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    affectedComponents: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    summary: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    target: string;
+    summary: string;
+    brokenEndpoints: string[];
+    brokenContracts: string[];
+    affectedTests: string[];
+    affectedFlows: string[];
+    affectedComponents: string[];
+}, {
+    target: string;
+    summary: string;
+    brokenEndpoints?: string[] | undefined;
+    brokenContracts?: string[] | undefined;
+    affectedTests?: string[] | undefined;
+    affectedFlows?: string[] | undefined;
+    affectedComponents?: string[] | undefined;
+}>;
+export declare const BusinessReviewOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["proceed", "defer", "reject"]>;
+    roiEstimate: z.ZodOptional<z.ZodString>;
+    userImpact: z.ZodOptional<z.ZodString>;
+    eliminationRisk: z.ZodOptional<z.ZodString>;
+    questions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    status: "proceed" | "defer" | "reject";
+    confidence: number;
+    questions: string[];
+    roiEstimate?: string | undefined;
+    userImpact?: string | undefined;
+    eliminationRisk?: string | undefined;
+}, {
+    status: "proceed" | "defer" | "reject";
+    confidence: number;
+    roiEstimate?: string | undefined;
+    userImpact?: string | undefined;
+    eliminationRisk?: string | undefined;
+    questions?: string[] | undefined;
+}>;
+export declare const VerificationReportSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    passed: z.ZodBoolean;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        passed: z.ZodBoolean;
+        message: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        name: string;
+        passed: boolean;
+    }, {
+        message: string;
+        name: string;
+        passed: boolean;
+    }>, "many">;
+    evidenceIds: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    confidence: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence: number;
+    taskId: string;
+    passed: boolean;
+    checks: {
+        message: string;
+        name: string;
+        passed: boolean;
+    }[];
+    evidenceIds: string[];
+}, {
+    confidence: number;
+    taskId: string;
+    passed: boolean;
+    checks: {
+        message: string;
+        name: string;
+        passed: boolean;
+    }[];
+    evidenceIds?: string[] | undefined;
+}>;
+export declare const BacklogStatusSchema: z.ZodEnum<["TODO", "READY", "PLANNED", "IN_PROGRESS", "BLOCKED", "REVIEW", "DONE"]>;
+export declare const BacklogTypeSchema: z.ZodEnum<["feature", "bug", "refactor", "tech-debt"]>;
+export declare const BacklogPrioritySchema: z.ZodEnum<["P0", "P1", "P2", "P3"]>;
+export declare const BacklogGlobalSchema: z.ZodObject<{
+    product: z.ZodString;
+    strategy: z.ZodString;
+    policy: z.ZodString;
+    reviewRequired: z.ZodBoolean;
+    tddRequired: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    strategy: string;
+    product: string;
+    policy: string;
+    reviewRequired: boolean;
+    tddRequired: boolean;
+}, {
+    strategy: string;
+    product: string;
+    policy: string;
+    reviewRequired: boolean;
+    tddRequired: boolean;
+}>;
+export declare const BacklogItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    priority: z.ZodEnum<["P0", "P1", "P2", "P3"]>;
+    status: z.ZodEnum<["TODO", "READY", "PLANNED", "IN_PROGRESS", "BLOCKED", "REVIEW", "DONE"]>;
+    type: z.ZodEnum<["feature", "bug", "refactor", "tech-debt"]>;
+    owner: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodString;
+    scope: z.ZodString;
+    outOfScope: z.ZodDefault<z.ZodString>;
+    businessValue: z.ZodOptional<z.ZodString>;
+    acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    risks: z.ZodOptional<z.ZodString>;
+    progress: z.ZodNumber;
+    branch: z.ZodOptional<z.ZodString>;
+    reviewer: z.ZodOptional<z.ZodString>;
+    lastUpdate: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+    type: "feature" | "refactor" | "bug" | "tech-debt";
+    description: string;
+    title: string;
+    acceptanceCriteria: string[];
+    dependencies: string[];
+    priority: "P0" | "P1" | "P2" | "P3";
+    scope: string;
+    outOfScope: string;
+    progress: number;
+    owner?: string | undefined;
+    businessValue?: string | undefined;
+    risks?: string | undefined;
+    branch?: string | undefined;
+    reviewer?: string | undefined;
+    lastUpdate?: string | undefined;
+}, {
+    id: string;
+    status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+    type: "feature" | "refactor" | "bug" | "tech-debt";
+    description: string;
+    title: string;
+    acceptanceCriteria: string[];
+    priority: "P0" | "P1" | "P2" | "P3";
+    scope: string;
+    progress: number;
+    dependencies?: string[] | undefined;
+    owner?: string | undefined;
+    outOfScope?: string | undefined;
+    businessValue?: string | undefined;
+    risks?: string | undefined;
+    branch?: string | undefined;
+    reviewer?: string | undefined;
+    lastUpdate?: string | undefined;
+}>;
+export declare const BacklogDocumentSchema: z.ZodObject<{
+    global: z.ZodObject<{
+        product: z.ZodString;
+        strategy: z.ZodString;
+        policy: z.ZodString;
+        reviewRequired: z.ZodBoolean;
+        tddRequired: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        strategy: string;
+        product: string;
+        policy: string;
+        reviewRequired: boolean;
+        tddRequired: boolean;
+    }, {
+        strategy: string;
+        product: string;
+        policy: string;
+        reviewRequired: boolean;
+        tddRequired: boolean;
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        priority: z.ZodEnum<["P0", "P1", "P2", "P3"]>;
+        status: z.ZodEnum<["TODO", "READY", "PLANNED", "IN_PROGRESS", "BLOCKED", "REVIEW", "DONE"]>;
+        type: z.ZodEnum<["feature", "bug", "refactor", "tech-debt"]>;
+        owner: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodString;
+        scope: z.ZodString;
+        outOfScope: z.ZodDefault<z.ZodString>;
+        businessValue: z.ZodOptional<z.ZodString>;
+        acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+        risks: z.ZodOptional<z.ZodString>;
+        progress: z.ZodNumber;
+        branch: z.ZodOptional<z.ZodString>;
+        reviewer: z.ZodOptional<z.ZodString>;
+        lastUpdate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        dependencies: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        outOfScope: string;
+        progress: number;
+        owner?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }, {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        progress: number;
+        dependencies?: string[] | undefined;
+        owner?: string | undefined;
+        outOfScope?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }>, "many">;
+    archive: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        priority: z.ZodEnum<["P0", "P1", "P2", "P3"]>;
+        status: z.ZodEnum<["TODO", "READY", "PLANNED", "IN_PROGRESS", "BLOCKED", "REVIEW", "DONE"]>;
+        type: z.ZodEnum<["feature", "bug", "refactor", "tech-debt"]>;
+        owner: z.ZodOptional<z.ZodString>;
+        dependencies: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodString;
+        scope: z.ZodString;
+        outOfScope: z.ZodDefault<z.ZodString>;
+        businessValue: z.ZodOptional<z.ZodString>;
+        acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+        risks: z.ZodOptional<z.ZodString>;
+        progress: z.ZodNumber;
+        branch: z.ZodOptional<z.ZodString>;
+        reviewer: z.ZodOptional<z.ZodString>;
+        lastUpdate: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        dependencies: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        outOfScope: string;
+        progress: number;
+        owner?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }, {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        progress: number;
+        dependencies?: string[] | undefined;
+        owner?: string | undefined;
+        outOfScope?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    global: {
+        strategy: string;
+        product: string;
+        policy: string;
+        reviewRequired: boolean;
+        tddRequired: boolean;
+    };
+    items: {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        dependencies: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        outOfScope: string;
+        progress: number;
+        owner?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }[];
+    archive: {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        dependencies: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        outOfScope: string;
+        progress: number;
+        owner?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }[];
+}, {
+    global: {
+        strategy: string;
+        product: string;
+        policy: string;
+        reviewRequired: boolean;
+        tddRequired: boolean;
+    };
+    items: {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        progress: number;
+        dependencies?: string[] | undefined;
+        owner?: string | undefined;
+        outOfScope?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }[];
+    archive?: {
+        id: string;
+        status: "TODO" | "READY" | "PLANNED" | "IN_PROGRESS" | "BLOCKED" | "REVIEW" | "DONE";
+        type: "feature" | "refactor" | "bug" | "tech-debt";
+        description: string;
+        title: string;
+        acceptanceCriteria: string[];
+        priority: "P0" | "P1" | "P2" | "P3";
+        scope: string;
+        progress: number;
+        dependencies?: string[] | undefined;
+        owner?: string | undefined;
+        outOfScope?: string | undefined;
+        businessValue?: string | undefined;
+        risks?: string | undefined;
+        branch?: string | undefined;
+        reviewer?: string | undefined;
+        lastUpdate?: string | undefined;
+    }[] | undefined;
+}>;
+export declare const OpenspecTaskCardPhaseSchema: z.ZodEnum<["discover", "design", "implement", "test", "review"]>;
+export declare const OpenspecTaskCardStatusSchema: z.ZodEnum<["pending", "doing", "blocked", "done"]>;
+export declare const OpenspecTaskCardSchema: z.ZodObject<{
+    id: z.ZodString;
+    backlogId: z.ZodString;
+    phase: z.ZodEnum<["discover", "design", "implement", "test", "review"]>;
+    title: z.ZodString;
+    prompt: z.ZodString;
+    agent: z.ZodString;
+    modelHint: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+    status: z.ZodEnum<["pending", "doing", "blocked", "done"]>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    status: "pending" | "done" | "blocked" | "doing";
+    title: string;
+    acceptanceCriteria: string[];
+    backlogId: string;
+    phase: "test" | "review" | "discover" | "design" | "implement";
+    prompt: string;
+    agent: string;
+    dependsOn: string[];
+    modelHint?: string | undefined;
+}, {
+    id: string;
+    status: "pending" | "done" | "blocked" | "doing";
+    title: string;
+    acceptanceCriteria: string[];
+    backlogId: string;
+    phase: "test" | "review" | "discover" | "design" | "implement";
+    prompt: string;
+    agent: string;
+    modelHint?: string | undefined;
+    dependsOn?: string[] | undefined;
+}>;
+export declare const OpenspecStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    activeItemId: z.ZodOptional<z.ZodString>;
+    taskCards: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        backlogId: z.ZodString;
+        phase: z.ZodEnum<["discover", "design", "implement", "test", "review"]>;
+        title: z.ZodString;
+        prompt: z.ZodString;
+        agent: z.ZodString;
+        modelHint: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        acceptanceCriteria: z.ZodArray<z.ZodString, "many">;
+        status: z.ZodEnum<["pending", "doing", "blocked", "done"]>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        status: "pending" | "done" | "blocked" | "doing";
+        title: string;
+        acceptanceCriteria: string[];
+        backlogId: string;
+        phase: "test" | "review" | "discover" | "design" | "implement";
+        prompt: string;
+        agent: string;
+        dependsOn: string[];
+        modelHint?: string | undefined;
+    }, {
+        id: string;
+        status: "pending" | "done" | "blocked" | "doing";
+        title: string;
+        acceptanceCriteria: string[];
+        backlogId: string;
+        phase: "test" | "review" | "discover" | "design" | "implement";
+        prompt: string;
+        agent: string;
+        modelHint?: string | undefined;
+        dependsOn?: string[] | undefined;
+    }>, "many">>;
+    lastScanHash: z.ZodOptional<z.ZodString>;
+    lastScanAt: z.ZodOptional<z.ZodString>;
+    changePaths: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    itemSnapshots: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    taskCards: {
+        id: string;
+        status: "pending" | "done" | "blocked" | "doing";
+        title: string;
+        acceptanceCriteria: string[];
+        backlogId: string;
+        phase: "test" | "review" | "discover" | "design" | "implement";
+        prompt: string;
+        agent: string;
+        dependsOn: string[];
+        modelHint?: string | undefined;
+    }[];
+    changePaths: Record<string, string>;
+    itemSnapshots: Record<string, string>;
+    activeItemId?: string | undefined;
+    lastScanHash?: string | undefined;
+    lastScanAt?: string | undefined;
+}, {
+    version: 1;
+    activeItemId?: string | undefined;
+    taskCards?: {
+        id: string;
+        status: "pending" | "done" | "blocked" | "doing";
+        title: string;
+        acceptanceCriteria: string[];
+        backlogId: string;
+        phase: "test" | "review" | "discover" | "design" | "implement";
+        prompt: string;
+        agent: string;
+        modelHint?: string | undefined;
+        dependsOn?: string[] | undefined;
+    }[] | undefined;
+    lastScanHash?: string | undefined;
+    lastScanAt?: string | undefined;
+    changePaths?: Record<string, string> | undefined;
+    itemSnapshots?: Record<string, string> | undefined;
+}>;
+export declare const WorkflowCommandSchema: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+export declare const CcepOutputFormatSchema: z.ZodEnum<["taskcard", "plan", "verdict"]>;
+export declare const CommandEnvelopeSchema: z.ZodObject<{
+    protocolVersion: z.ZodLiteral<"ccep-1">;
+    command: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+    userRequest: z.ZodString;
+    projectId: z.ZodString;
+    repoContext: z.ZodObject<{
+        domain: z.ZodOptional<z.ZodString>;
+        stack: z.ZodArray<z.ZodString, "many">;
+        existingModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        architecture: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        stack: string[];
+        existingModules: string[];
+        domain?: string | undefined;
+        architecture?: string | undefined;
+    }, {
+        stack: string[];
+        domain?: string | undefined;
+        existingModules?: string[] | undefined;
+        architecture?: string | undefined;
+    }>;
+    constraints: z.ZodObject<{
+        outputFormat: z.ZodEnum<["taskcard", "plan", "verdict"]>;
+        needConfirmation: z.ZodBoolean;
+        riskThreshold: z.ZodEnum<["low", "medium", "high"]>;
+    }, "strip", z.ZodTypeAny, {
+        outputFormat: "taskcard" | "plan" | "verdict";
+        needConfirmation: boolean;
+        riskThreshold: "low" | "medium" | "high";
+    }, {
+        outputFormat: "taskcard" | "plan" | "verdict";
+        needConfirmation: boolean;
+        riskThreshold: "low" | "medium" | "high";
+    }>;
+    executionPolicy: z.ZodObject<{
+        modelMode: z.ZodLiteral<"structured">;
+        maxVariance: z.ZodLiteral<"low">;
+    }, "strip", z.ZodTypeAny, {
+        modelMode: "structured";
+        maxVariance: "low";
+    }, {
+        modelMode: "structured";
+        maxVariance: "low";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    constraints: {
+        outputFormat: "taskcard" | "plan" | "verdict";
+        needConfirmation: boolean;
+        riskThreshold: "low" | "medium" | "high";
+    };
+    protocolVersion: "ccep-1";
+    userRequest: string;
+    projectId: string;
+    repoContext: {
+        stack: string[];
+        existingModules: string[];
+        domain?: string | undefined;
+        architecture?: string | undefined;
+    };
+    executionPolicy: {
+        modelMode: "structured";
+        maxVariance: "low";
+    };
+}, {
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    constraints: {
+        outputFormat: "taskcard" | "plan" | "verdict";
+        needConfirmation: boolean;
+        riskThreshold: "low" | "medium" | "high";
+    };
+    protocolVersion: "ccep-1";
+    userRequest: string;
+    projectId: string;
+    repoContext: {
+        stack: string[];
+        domain?: string | undefined;
+        existingModules?: string[] | undefined;
+        architecture?: string | undefined;
+    };
+    executionPolicy: {
+        modelMode: "structured";
+        maxVariance: "low";
+    };
+}>;
+export declare const WorkflowPhaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    agent: z.ZodOptional<z.ZodString>;
+    agents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    skill: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    outputSchema: z.ZodOptional<z.ZodString>;
+    stopGate: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    requires: z.ZodOptional<z.ZodString>;
+    parallelWith: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type?: string | undefined;
+    agents?: string[] | undefined;
+    agent?: string | undefined;
+    dependsOn?: string[] | undefined;
+    skill?: string | undefined;
+    outputSchema?: string | undefined;
+    stopGate?: string | undefined;
+    requires?: string | undefined;
+    parallelWith?: string[] | undefined;
+}, {
+    id: string;
+    type?: string | undefined;
+    agents?: string[] | undefined;
+    agent?: string | undefined;
+    dependsOn?: string[] | undefined;
+    skill?: string | undefined;
+    outputSchema?: string | undefined;
+    stopGate?: string | undefined;
+    requires?: string | undefined;
+    parallelWith?: string[] | undefined;
+}>;
+export declare const WorkflowRiskRuleSchema: z.ZodObject<{
+    when: z.ZodObject<{
+        risk: z.ZodUnion<[z.ZodEnum<["low", "medium", "high"]>, z.ZodArray<z.ZodEnum<["low", "medium", "high"]>, "many">]>;
+    }, "strip", z.ZodTypeAny, {
+        risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+    }, {
+        risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+    }>;
+    then: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    when: {
+        risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+    };
+    then: string[];
+}, {
+    when: {
+        risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+    };
+    then: string[];
+}>;
+export declare const WorkflowProfileSchema: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    command: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+    taskCard: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        requiredFields: z.ZodArray<z.ZodString, "many">;
+        optionalFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    }, {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    }>>;
+    intakeSchema: z.ZodOptional<z.ZodString>;
+    phases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agent: z.ZodOptional<z.ZodString>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        skill: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+        outputSchema: z.ZodOptional<z.ZodString>;
+        stopGate: z.ZodOptional<z.ZodString>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        requires: z.ZodOptional<z.ZodString>;
+        parallelWith: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }, {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }>, "many">;
+    routing: z.ZodObject<{
+        default: z.ZodArray<z.ZodString, "many">;
+        riskRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            when: z.ZodObject<{
+                risk: z.ZodUnion<[z.ZodEnum<["low", "medium", "high"]>, z.ZodArray<z.ZodEnum<["low", "medium", "high"]>, "many">]>;
+            }, "strip", z.ZodTypeAny, {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            }, {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            }>;
+            then: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }, {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    }, {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    }>;
+    confirmationGate: z.ZodObject<{
+        stopOnHighRisk: z.ZodBoolean;
+        stopOnQuestions: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    }, {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: number;
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    phases: {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }[];
+    routing: {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    };
+    confirmationGate: {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    };
+    taskCard?: {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    } | undefined;
+    intakeSchema?: string | undefined;
+}, {
+    id: string;
+    version: number;
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    phases: {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }[];
+    routing: {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    };
+    confirmationGate: {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    };
+    taskCard?: {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    } | undefined;
+    intakeSchema?: string | undefined;
+}>, {
+    id: string;
+    version: number;
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    phases: {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }[];
+    routing: {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    };
+    confirmationGate: {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    };
+    taskCard?: {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    } | undefined;
+    intakeSchema?: string | undefined;
+}, {
+    id: string;
+    version: number;
+    command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+    phases: {
+        id: string;
+        type?: string | undefined;
+        agents?: string[] | undefined;
+        agent?: string | undefined;
+        dependsOn?: string[] | undefined;
+        skill?: string | undefined;
+        outputSchema?: string | undefined;
+        stopGate?: string | undefined;
+        requires?: string | undefined;
+        parallelWith?: string[] | undefined;
+    }[];
+    routing: {
+        default: string[];
+        riskRules?: {
+            when: {
+                risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+            };
+            then: string[];
+        }[] | undefined;
+    };
+    confirmationGate: {
+        stopOnHighRisk: boolean;
+        stopOnQuestions: boolean;
+    };
+    taskCard?: {
+        type: string;
+        requiredFields: string[];
+        optionalFields?: string[] | undefined;
+    } | undefined;
+    intakeSchema?: string | undefined;
+}>;
+export declare const ExecutionContextSchema: z.ZodObject<{
+    envelope: z.ZodObject<{
+        protocolVersion: z.ZodLiteral<"ccep-1">;
+        command: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+        userRequest: z.ZodString;
+        projectId: z.ZodString;
+        repoContext: z.ZodObject<{
+            domain: z.ZodOptional<z.ZodString>;
+            stack: z.ZodArray<z.ZodString, "many">;
+            existingModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            architecture: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            stack: string[];
+            existingModules: string[];
+            domain?: string | undefined;
+            architecture?: string | undefined;
+        }, {
+            stack: string[];
+            domain?: string | undefined;
+            existingModules?: string[] | undefined;
+            architecture?: string | undefined;
+        }>;
+        constraints: z.ZodObject<{
+            outputFormat: z.ZodEnum<["taskcard", "plan", "verdict"]>;
+            needConfirmation: z.ZodBoolean;
+            riskThreshold: z.ZodEnum<["low", "medium", "high"]>;
+        }, "strip", z.ZodTypeAny, {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        }, {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        }>;
+        executionPolicy: z.ZodObject<{
+            modelMode: z.ZodLiteral<"structured">;
+            maxVariance: z.ZodLiteral<"low">;
+        }, "strip", z.ZodTypeAny, {
+            modelMode: "structured";
+            maxVariance: "low";
+        }, {
+            modelMode: "structured";
+            maxVariance: "low";
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        constraints: {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        };
+        protocolVersion: "ccep-1";
+        userRequest: string;
+        projectId: string;
+        repoContext: {
+            stack: string[];
+            existingModules: string[];
+            domain?: string | undefined;
+            architecture?: string | undefined;
+        };
+        executionPolicy: {
+            modelMode: "structured";
+            maxVariance: "low";
+        };
+    }, {
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        constraints: {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        };
+        protocolVersion: "ccep-1";
+        userRequest: string;
+        projectId: string;
+        repoContext: {
+            stack: string[];
+            domain?: string | undefined;
+            existingModules?: string[] | undefined;
+            architecture?: string | undefined;
+        };
+        executionPolicy: {
+            modelMode: "structured";
+            maxVariance: "low";
+        };
+    }>;
+    profile: z.ZodEffects<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodNumber;
+        command: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+        taskCard: z.ZodOptional<z.ZodObject<{
+            type: z.ZodString;
+            requiredFields: z.ZodArray<z.ZodString, "many">;
+            optionalFields: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        }, {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        }>>;
+        intakeSchema: z.ZodOptional<z.ZodString>;
+        phases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            agent: z.ZodOptional<z.ZodString>;
+            agents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            skill: z.ZodOptional<z.ZodString>;
+            type: z.ZodOptional<z.ZodString>;
+            outputSchema: z.ZodOptional<z.ZodString>;
+            stopGate: z.ZodOptional<z.ZodString>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            requires: z.ZodOptional<z.ZodString>;
+            parallelWith: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }, {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }>, "many">;
+        routing: z.ZodObject<{
+            default: z.ZodArray<z.ZodString, "many">;
+            riskRules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                when: z.ZodObject<{
+                    risk: z.ZodUnion<[z.ZodEnum<["low", "medium", "high"]>, z.ZodArray<z.ZodEnum<["low", "medium", "high"]>, "many">]>;
+                }, "strip", z.ZodTypeAny, {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                }, {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                }>;
+                then: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }, {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        }, {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        }>;
+        confirmationGate: z.ZodObject<{
+            stopOnHighRisk: z.ZodBoolean;
+            stopOnQuestions: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        }, {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    }, {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    }>, {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    }, {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    }>;
+    intent: z.ZodObject<{
+        type: z.ZodEnum<["feature", "fix", "refactor", "review", "test-plan", "tdd-cycle", "api-contract", "db-migration", "pagespeed", "openspec", "scorecard", "council", "iterative", "explore", "triage", "prototype", "handoff", "clarify"]>;
+        goal: z.ZodString;
+        domain: z.ZodOptional<z.ZodString>;
+        entity: z.ZodOptional<z.ZodString>;
+        operation: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        goal: string;
+        domain?: string | undefined;
+        entity?: string | undefined;
+        operation?: string | undefined;
+    }, {
+        type: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        goal: string;
+        domain?: string | undefined;
+        entity?: string | undefined;
+        operation?: string | undefined;
+    }>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+        rootDir: z.ZodString;
+        stack: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        rootDir: string;
+        stack?: string[] | undefined;
+    }, {
+        name: string;
+        rootDir: string;
+        stack?: string[] | undefined;
+    }>;
+    knowledge: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ast: z.ZodObject<{
+        source: z.ZodEnum<["detect", "graphify", "manual", "product-graph"]>;
+        confidence: z.ZodEnum<["low", "medium", "high"]>;
+        domains: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+        rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        confidence: "low" | "medium" | "high";
+        source: "detect" | "graphify" | "manual" | "product-graph";
+        domains?: unknown[] | undefined;
+        rules?: string[] | undefined;
+    }, {
+        confidence: "low" | "medium" | "high";
+        source: "detect" | "graphify" | "manual" | "product-graph";
+        domains?: unknown[] | undefined;
+        rules?: string[] | undefined;
+    }>;
+    policies: z.ZodObject<{
+        architecture: z.ZodString;
+        testing: z.ZodString;
+        documentation: z.ZodString;
+        breakingChanges: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        architecture: string;
+        testing: string;
+        documentation: string;
+        breakingChanges: string;
+    }, {
+        architecture: string;
+        testing: string;
+        documentation: string;
+        breakingChanges: string;
+    }>;
+    currentPhase: z.ZodOptional<z.ZodString>;
+    outputSchema: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    project: {
+        name: string;
+        rootDir: string;
+        stack?: string[] | undefined;
+    };
+    profile: {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    };
+    outputSchema: string;
+    envelope: {
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        constraints: {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        };
+        protocolVersion: "ccep-1";
+        userRequest: string;
+        projectId: string;
+        repoContext: {
+            stack: string[];
+            existingModules: string[];
+            domain?: string | undefined;
+            architecture?: string | undefined;
+        };
+        executionPolicy: {
+            modelMode: "structured";
+            maxVariance: "low";
+        };
+    };
+    intent: {
+        type: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        goal: string;
+        domain?: string | undefined;
+        entity?: string | undefined;
+        operation?: string | undefined;
+    };
+    knowledge: Record<string, unknown>;
+    ast: {
+        confidence: "low" | "medium" | "high";
+        source: "detect" | "graphify" | "manual" | "product-graph";
+        domains?: unknown[] | undefined;
+        rules?: string[] | undefined;
+    };
+    policies: {
+        architecture: string;
+        testing: string;
+        documentation: string;
+        breakingChanges: string;
+    };
+    currentPhase?: string | undefined;
+}, {
+    project: {
+        name: string;
+        rootDir: string;
+        stack?: string[] | undefined;
+    };
+    profile: {
+        id: string;
+        version: number;
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        phases: {
+            id: string;
+            type?: string | undefined;
+            agents?: string[] | undefined;
+            agent?: string | undefined;
+            dependsOn?: string[] | undefined;
+            skill?: string | undefined;
+            outputSchema?: string | undefined;
+            stopGate?: string | undefined;
+            requires?: string | undefined;
+            parallelWith?: string[] | undefined;
+        }[];
+        routing: {
+            default: string[];
+            riskRules?: {
+                when: {
+                    risk: "low" | "medium" | "high" | ("low" | "medium" | "high")[];
+                };
+                then: string[];
+            }[] | undefined;
+        };
+        confirmationGate: {
+            stopOnHighRisk: boolean;
+            stopOnQuestions: boolean;
+        };
+        taskCard?: {
+            type: string;
+            requiredFields: string[];
+            optionalFields?: string[] | undefined;
+        } | undefined;
+        intakeSchema?: string | undefined;
+    };
+    outputSchema: string;
+    envelope: {
+        command: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        constraints: {
+            outputFormat: "taskcard" | "plan" | "verdict";
+            needConfirmation: boolean;
+            riskThreshold: "low" | "medium" | "high";
+        };
+        protocolVersion: "ccep-1";
+        userRequest: string;
+        projectId: string;
+        repoContext: {
+            stack: string[];
+            domain?: string | undefined;
+            existingModules?: string[] | undefined;
+            architecture?: string | undefined;
+        };
+        executionPolicy: {
+            modelMode: "structured";
+            maxVariance: "low";
+        };
+    };
+    intent: {
+        type: "council" | "feature" | "fix" | "refactor" | "review" | "test-plan" | "tdd-cycle" | "api-contract" | "db-migration" | "pagespeed" | "openspec" | "scorecard" | "iterative" | "explore" | "triage" | "prototype" | "handoff" | "clarify";
+        goal: string;
+        domain?: string | undefined;
+        entity?: string | undefined;
+        operation?: string | undefined;
+    };
+    ast: {
+        confidence: "low" | "medium" | "high";
+        source: "detect" | "graphify" | "manual" | "product-graph";
+        domains?: unknown[] | undefined;
+        rules?: string[] | undefined;
+    };
+    policies: {
+        architecture: string;
+        testing: string;
+        documentation: string;
+        breakingChanges: string;
+    };
+    knowledge?: Record<string, unknown> | undefined;
+    currentPhase?: string | undefined;
+}>;
+export declare const PlannerOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["success", "needs_clarification"]>;
+    confidence: z.ZodNumber;
+    goal: z.ZodString;
+    assumptions: z.ZodArray<z.ZodString, "many">;
+    risks: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        description: z.ZodString;
+        severity: z.ZodEnum<["low", "medium", "high"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        description: string;
+        severity: "low" | "medium" | "high";
+    }, {
+        type: string;
+        description: string;
+        severity: "low" | "medium" | "high";
+    }>, "many">;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        priority: z.ZodString;
+        estimate: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: string;
+        estimate: string;
+    }, {
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: string;
+        estimate: string;
+    }>, "many">;
+    questionsForUser: z.ZodArray<z.ZodString, "many">;
+    needsConfirmation: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    status: "success" | "needs_clarification";
+    confidence: number;
+    tasks: {
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: string;
+        estimate: string;
+    }[];
+    risks: {
+        type: string;
+        description: string;
+        severity: "low" | "medium" | "high";
+    }[];
+    goal: string;
+    assumptions: string[];
+    questionsForUser: string[];
+    needsConfirmation: boolean;
+}, {
+    status: "success" | "needs_clarification";
+    confidence: number;
+    tasks: {
+        id: string;
+        title: string;
+        dependencies: string[];
+        priority: string;
+        estimate: string;
+    }[];
+    risks: {
+        type: string;
+        description: string;
+        severity: "low" | "medium" | "high";
+    }[];
+    goal: string;
+    assumptions: string[];
+    questionsForUser: string[];
+    needsConfirmation: boolean;
+}>;
+export declare const AgentArtifactSchema: z.ZodObject<{
+    type: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    content: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    path?: string | undefined;
+    content?: string | undefined;
+}, {
+    type: string;
+    path?: string | undefined;
+    content?: string | undefined;
+}>;
+export declare const AgentOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["success", "failure", "blocked", "needs_clarification"]>;
+    confidence: z.ZodNumber;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }>, "many">>;
+    next_actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "blocked" | "success" | "needs_clarification" | "failure";
+    confidence: number;
+    warnings: string[];
+    artifacts: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[];
+    next_actions: string[];
+}, {
+    status: "blocked" | "success" | "needs_clarification" | "failure";
+    confidence: number;
+    warnings?: string[] | undefined;
+    artifacts?: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[] | undefined;
+    next_actions?: string[] | undefined;
+}>;
+export declare const ImplementerTestsSchema: z.ZodObject<{
+    runner: z.ZodString;
+    result: z.ZodEnum<["passed", "failed"]>;
+    failedTests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    runner: string;
+    result: "passed" | "failed";
+    failedTests?: string[] | undefined;
+}, {
+    runner: string;
+    result: "passed" | "failed";
+    failedTests?: string[] | undefined;
+}>;
+export declare const ImplementerOutputSchema: z.ZodObject<{
+    confidence: z.ZodNumber;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }>, "many">>;
+    next_actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    status: z.ZodEnum<["success", "failure", "blocked"]>;
+    filesChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        summary: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        summary: string;
+    }, {
+        path: string;
+        summary: string;
+    }>, "many">>;
+    tests: z.ZodOptional<z.ZodObject<{
+        runner: z.ZodString;
+        result: z.ZodEnum<["passed", "failed"]>;
+        failedTests: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        runner: string;
+        result: "passed" | "failed";
+        failedTests?: string[] | undefined;
+    }, {
+        runner: string;
+        result: "passed" | "failed";
+        failedTests?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    status: "blocked" | "success" | "failure";
+    confidence: number;
+    warnings: string[];
+    artifacts: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[];
+    next_actions: string[];
+    filesChanged: {
+        path: string;
+        summary: string;
+    }[];
+    tests?: {
+        runner: string;
+        result: "passed" | "failed";
+        failedTests?: string[] | undefined;
+    } | undefined;
+}, {
+    status: "blocked" | "success" | "failure";
+    confidence: number;
+    warnings?: string[] | undefined;
+    artifacts?: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[] | undefined;
+    next_actions?: string[] | undefined;
+    filesChanged?: {
+        path: string;
+        summary: string;
+    }[] | undefined;
+    tests?: {
+        runner: string;
+        result: "passed" | "failed";
+        failedTests?: string[] | undefined;
+    } | undefined;
+}>;
+export declare const ReviewAxisSchema: z.ZodEnum<["complexity", "cost", "performance", "maintainability", "security", "scalability", "style"]>;
+export declare const ReviewFindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<["CRITICAL", "WARNING", "SUGGESTION"]>;
+    message: z.ZodString;
+    axis: z.ZodUnion<[z.ZodEnum<["complexity", "cost", "performance", "maintainability", "security", "scalability", "style"]>, z.ZodString]>;
+    path: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+    axis: string;
+    path?: string | undefined;
+    line?: number | undefined;
+}, {
+    message: string;
+    severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+    axis: string;
+    path?: string | undefined;
+    line?: number | undefined;
+}>;
+export declare const ReviewerOutputSchema: z.ZodObject<{
+    status: z.ZodEnum<["pass", "fail"]>;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<["approved", "approved_with_warnings", "blocked"]>;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<["CRITICAL", "WARNING", "SUGGESTION"]>;
+        message: z.ZodString;
+        axis: z.ZodUnion<[z.ZodEnum<["complexity", "cost", "performance", "maintainability", "security", "scalability", "style"]>, z.ZodString]>;
+        path: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+        axis: string;
+        path?: string | undefined;
+        line?: number | undefined;
+    }, {
+        message: string;
+        severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+        axis: string;
+        path?: string | undefined;
+        line?: number | undefined;
+    }>, "many">>;
+    artifacts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        content: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }, {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }>, "many">>;
+    next_actions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    status: "pass" | "fail";
+    confidence: number;
+    findings: {
+        message: string;
+        severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+        axis: string;
+        path?: string | undefined;
+        line?: number | undefined;
+    }[];
+    verdict: "blocked" | "approved" | "approved_with_warnings";
+    warnings: string[];
+    artifacts: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[];
+    next_actions: string[];
+}, {
+    status: "pass" | "fail";
+    confidence: number;
+    verdict: "blocked" | "approved" | "approved_with_warnings";
+    findings?: {
+        message: string;
+        severity: "CRITICAL" | "WARNING" | "SUGGESTION";
+        axis: string;
+        path?: string | undefined;
+        line?: number | undefined;
+    }[] | undefined;
+    warnings?: string[] | undefined;
+    artifacts?: {
+        type: string;
+        path?: string | undefined;
+        content?: string | undefined;
+    }[] | undefined;
+    next_actions?: string[] | undefined;
+}>;
+export declare const TechnicalPlanOutputSchema: z.ZodObject<{
+    approach: z.ZodString;
+    filesAffected: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    risks: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    openQuestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    risks: string[];
+    approach: string;
+    filesAffected: string[];
+    openQuestions?: string[] | undefined;
+}, {
+    approach: string;
+    risks?: string[] | undefined;
+    filesAffected?: string[] | undefined;
+    openQuestions?: string[] | undefined;
+}>;
+export declare const ScorecardVerdictSchema: z.ZodEnum<["PASS", "REVISE", "REJECT"]>;
+export declare const ScorecardCriterionIdSchema: z.ZodEnum<["acceptance", "minimal_diff", "tests", "regressions", "conventions", "documentation", "context_discipline", "cc_gain"]>;
+export declare const ScorecardCriterionSchema: z.ZodObject<{
+    id: z.ZodEnum<["acceptance", "minimal_diff", "tests", "regressions", "conventions", "documentation", "context_discipline", "cc_gain"]>;
+    label: z.ZodString;
+    weight: z.ZodNumber;
+    score: z.ZodNumber;
+    notes: z.ZodOptional<z.ZodString>;
+    autoSuggested: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+    label: string;
+    weight: number;
+    score: number;
+    notes?: string | undefined;
+    autoSuggested?: boolean | undefined;
+}, {
+    id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+    label: string;
+    weight: number;
+    score: number;
+    notes?: string | undefined;
+    autoSuggested?: boolean | undefined;
+}>;
+export declare const ScorecardRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+    agent: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    contractVersion: z.ZodString;
+    evaluator: z.ZodOptional<z.ZodString>;
+    criteria: z.ZodArray<z.ZodObject<{
+        id: z.ZodEnum<["acceptance", "minimal_diff", "tests", "regressions", "conventions", "documentation", "context_discipline", "cc_gain"]>;
+        label: z.ZodString;
+        weight: z.ZodNumber;
+        score: z.ZodNumber;
+        notes: z.ZodOptional<z.ZodString>;
+        autoSuggested: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+        label: string;
+        weight: number;
+        score: number;
+        notes?: string | undefined;
+        autoSuggested?: boolean | undefined;
+    }, {
+        id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+        label: string;
+        weight: number;
+        score: number;
+        notes?: string | undefined;
+        autoSuggested?: boolean | undefined;
+    }>, "many">;
+    weightedScore: z.ZodNumber;
+    verdict: z.ZodEnum<["PASS", "REVISE", "REJECT"]>;
+    findings: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    createdAt: z.ZodString;
+    backlogId: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodEnum<["openspec", "review", "manual", "pipeline"]>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    contractVersion: string;
+    findings: string[];
+    taskId: string;
+    agent: string;
+    verdict: "PASS" | "REVISE" | "REJECT";
+    criteria: {
+        id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+        label: string;
+        weight: number;
+        score: number;
+        notes?: string | undefined;
+        autoSuggested?: boolean | undefined;
+    }[];
+    weightedScore: number;
+    createdAt: string;
+    source?: "review" | "openspec" | "manual" | "pipeline" | undefined;
+    backlogId?: string | undefined;
+    model?: string | undefined;
+    evaluator?: string | undefined;
+}, {
+    id: string;
+    contractVersion: string;
+    taskId: string;
+    agent: string;
+    verdict: "PASS" | "REVISE" | "REJECT";
+    criteria: {
+        id: "documentation" | "tests" | "acceptance" | "minimal_diff" | "regressions" | "conventions" | "context_discipline" | "cc_gain";
+        label: string;
+        weight: number;
+        score: number;
+        notes?: string | undefined;
+        autoSuggested?: boolean | undefined;
+    }[];
+    weightedScore: number;
+    createdAt: string;
+    findings?: string[] | undefined;
+    source?: "review" | "openspec" | "manual" | "pipeline" | undefined;
+    backlogId?: string | undefined;
+    model?: string | undefined;
+    evaluator?: string | undefined;
+}>;
+export declare const TaskOutcomeSourceSchema: z.ZodEnum<["openspec", "review", "manual", "pipeline"]>;
+export declare const TaskOutcomeStatusSchema: z.ZodEnum<["phase_done", "phase_failed", "pass", "revise", "reject"]>;
+export declare const TaskOutcomeSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+    source: z.ZodEnum<["openspec", "review", "manual", "pipeline"]>;
+    agent: z.ZodString;
+    model: z.ZodString;
+    contractVersion: z.ZodString;
+    timestamp: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<["phase_done", "phase_failed", "pass", "revise", "reject"]>>;
+    verdict: z.ZodOptional<z.ZodEnum<["PASS", "REVISE", "REJECT"]>>;
+    weightedScore: z.ZodOptional<z.ZodNumber>;
+    taskCardId: z.ZodOptional<z.ZodString>;
+    backlogId: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodString>;
+    scorecardId: z.ZodOptional<z.ZodString>;
+    tokensIn: z.ZodOptional<z.ZodNumber>;
+    tokensOut: z.ZodOptional<z.ZodNumber>;
+    costUsd: z.ZodOptional<z.ZodNumber>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    contractVersion: string;
+    timestamp: string;
+    source: "review" | "openspec" | "manual" | "pipeline";
+    taskId: string;
+    agent: string;
+    model: string;
+    status?: "reject" | "pass" | "phase_done" | "phase_failed" | "revise" | undefined;
+    backlogId?: string | undefined;
+    phase?: string | undefined;
+    verdict?: "PASS" | "REVISE" | "REJECT" | undefined;
+    weightedScore?: number | undefined;
+    taskCardId?: string | undefined;
+    scorecardId?: string | undefined;
+    tokensIn?: number | undefined;
+    tokensOut?: number | undefined;
+    costUsd?: number | undefined;
+    durationMs?: number | undefined;
+}, {
+    id: string;
+    contractVersion: string;
+    timestamp: string;
+    source: "review" | "openspec" | "manual" | "pipeline";
+    taskId: string;
+    agent: string;
+    model: string;
+    status?: "reject" | "pass" | "phase_done" | "phase_failed" | "revise" | undefined;
+    backlogId?: string | undefined;
+    phase?: string | undefined;
+    verdict?: "PASS" | "REVISE" | "REJECT" | undefined;
+    weightedScore?: number | undefined;
+    taskCardId?: string | undefined;
+    scorecardId?: string | undefined;
+    tokensIn?: number | undefined;
+    tokensOut?: number | undefined;
+    costUsd?: number | undefined;
+    durationMs?: number | undefined;
+}>;
+export declare const EvaluationIndexSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    lastOutcomeId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    version: 1;
+    lastOutcomeId?: string | undefined;
+}, {
+    version: 1;
+    lastOutcomeId?: string | undefined;
+}>;
+export declare const ExecutionProfileNameSchema: z.ZodEnum<["balanced", "quality", "economical"]>;
+export declare const ExecutionProfileSchema: z.ZodObject<{
+    profile: z.ZodDefault<z.ZodEnum<["balanced", "quality", "economical"]>>;
+    target: z.ZodOptional<z.ZodEnum<["opencode", "claude", "codex", "gemini", "cursor", "agy"]>>;
+    overrides: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    subagentPolicy: z.ZodOptional<z.ZodObject<{
+        orchestrator: z.ZodOptional<z.ZodEnum<["primary", "delegate"]>>;
+        testerReviewer: z.ZodOptional<z.ZodEnum<["primary", "delegate"]>>;
+    }, "strip", z.ZodTypeAny, {
+        orchestrator?: "primary" | "delegate" | undefined;
+        testerReviewer?: "primary" | "delegate" | undefined;
+    }, {
+        orchestrator?: "primary" | "delegate" | undefined;
+        testerReviewer?: "primary" | "delegate" | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    profile: "balanced" | "quality" | "economical";
+    overrides: Record<string, string>;
+    target?: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy" | undefined;
+    subagentPolicy?: {
+        orchestrator?: "primary" | "delegate" | undefined;
+        testerReviewer?: "primary" | "delegate" | undefined;
+    } | undefined;
+}, {
+    profile?: "balanced" | "quality" | "economical" | undefined;
+    target?: "opencode" | "claude" | "codex" | "gemini" | "cursor" | "agy" | undefined;
+    overrides?: Record<string, string> | undefined;
+    subagentPolicy?: {
+        orchestrator?: "primary" | "delegate" | undefined;
+        testerReviewer?: "primary" | "delegate" | undefined;
+    } | undefined;
+}>;
+export type ContractTargetInput = z.infer<typeof ContractTargetSchema>;
+export type ContractFormatInput = z.infer<typeof ContractFormatSchema>;
+export type AgentContractInput = z.infer<typeof AgentContractSchema>;
+export type CouncilFindingInput = z.infer<typeof CouncilFindingSchema>;
+export type CouncilVerdictInputData = z.infer<typeof CouncilVerdictInputSchema>;
+export type ConsensusConfigInput = z.infer<typeof ConsensusConfigSchema>;
+export type CouncilVerdictOutput = z.infer<typeof CouncilVerdictSchema>;
+export type GoalTaskInput = z.infer<typeof GoalTaskSchema>;
+export type GoalGraphInput = z.infer<typeof GoalGraphSchema>;
+export type KnowledgeEntityInput = z.infer<typeof KnowledgeEntitySchema>;
+export type DecisionInput = z.infer<typeof DecisionSchema>;
+export type EvidenceInput = z.infer<typeof EvidenceSchema>;
+export type CanonicalTaskCardInput = z.infer<typeof CanonicalTaskCardSchema>;
+export type ProductGraphInput = z.infer<typeof ProductGraphSchema>;
+export type ProductGraphNodeInput = z.infer<typeof ProductGraphNodeSchema>;
+export type ProductGraphEdgeInput = z.infer<typeof ProductGraphEdgeSchema>;
+export type ProductMetaInput = z.infer<typeof ProductMetaSchema>;
+export type ProductEventInput = z.infer<typeof ProductEventSchema>;
+export type OperationalStateInput = z.infer<typeof OperationalStateSchema>;
+export type StrategicMemoryInput = z.infer<typeof StrategicMemorySchema>;
+export type ImpactReportInput = z.infer<typeof ImpactReportSchema>;
+export type BusinessReviewOutputInput = z.infer<typeof BusinessReviewOutputSchema>;
+export type VerificationReportInput = z.infer<typeof VerificationReportSchema>;
+export type MemoryPointerInput = z.infer<typeof MemoryPointerSchema>;
+export type MemoryIndexInput = z.infer<typeof MemoryIndexSchema>;
+export type BacklogStatusInput = z.infer<typeof BacklogStatusSchema>;
+export type BacklogTypeInput = z.infer<typeof BacklogTypeSchema>;
+export type BacklogPriorityInput = z.infer<typeof BacklogPrioritySchema>;
+export type BacklogGlobalInput = z.infer<typeof BacklogGlobalSchema>;
+export type BacklogItemInput = z.infer<typeof BacklogItemSchema>;
+export type BacklogDocumentInput = z.infer<typeof BacklogDocumentSchema>;
+export type OpenspecTaskCardPhaseInput = z.infer<typeof OpenspecTaskCardPhaseSchema>;
+export type OpenspecTaskCardStatusInput = z.infer<typeof OpenspecTaskCardStatusSchema>;
+export type OpenspecTaskCardInput = z.infer<typeof OpenspecTaskCardSchema>;
+export type OpenspecStateInput = z.infer<typeof OpenspecStateSchema>;
+export type ScorecardVerdictInput = z.infer<typeof ScorecardVerdictSchema>;
+export type ScorecardCriterionInput = z.infer<typeof ScorecardCriterionSchema>;
+export type ScorecardRecordInput = z.infer<typeof ScorecardRecordSchema>;
+export type TaskOutcomeInput = z.infer<typeof TaskOutcomeSchema>;
+export type EvaluationIndexInput = z.infer<typeof EvaluationIndexSchema>;
+export type ExecutionProfileInput = z.infer<typeof ExecutionProfileSchema>;
+export type WorkflowCommandInput = z.infer<typeof WorkflowCommandSchema>;
+export type CommandEnvelopeInput = z.infer<typeof CommandEnvelopeSchema>;
+export type WorkflowProfileInput = z.infer<typeof WorkflowProfileSchema>;
+export type ExecutionContextInput = z.infer<typeof ExecutionContextSchema>;
+export type PlannerOutputInput = z.infer<typeof PlannerOutputSchema>;
+export type AgentOutputInput = z.infer<typeof AgentOutputSchema>;
+export type ImplementerOutputInput = z.infer<typeof ImplementerOutputSchema>;
+export type ReviewerOutputInput = z.infer<typeof ReviewerOutputSchema>;
+/**
+ * Validate agent contract input
+ */
+export declare function validateAgentContract(data: unknown): AgentContractInput;
+/**
+ * Validate council verdict input
+ */
+export declare function validateCouncilVerdictInput(data: unknown): CouncilVerdictInputData;
+/**
+ * Validate consensus config
+ */
+export declare function validateConsensusConfig(data: unknown): ConsensusConfigInput;
+/**
+ * Validate council verdict output
+ */
+export declare function validateCouncilVerdict(data: unknown): CouncilVerdictOutput;
+/**
+ * Validate a Claude agent file
+ */
+export declare function validateClaudeAgentFile(data: unknown): z.infer<typeof ClaudeAgentFileSchema>;
+/**
+ * Validate an OpenCode agent file
+ */
+export declare function validateOpenCodeAgentFile(data: unknown): z.infer<typeof OpenCodeAgentFileSchema>;
+/**
+ * Validate goal graph
+ */
+export declare function validateGoalGraph(data: unknown): z.infer<typeof GoalGraphSchema>;
+/**
+ * Validate memory pointer
+ */
+export declare function validateMemoryPointer(data: unknown): z.infer<typeof MemoryPointerSchema>;
+/**
+ * Validate memory index
+ */
+export declare function validateMemoryIndex(data: unknown): z.infer<typeof MemoryIndexSchema>;
+/**
+ * Validate backlog document
+ */
+export declare function validateBacklogDocument(data: unknown): BacklogDocumentInput;
+/**
+ * Validate openspec state
+ */
+export declare function validateOpenspecState(data: unknown): OpenspecStateInput;
+export declare function validateScorecardRecord(data: unknown): ScorecardRecordInput;
+export declare function validateTaskOutcome(data: unknown): TaskOutcomeInput;
+export declare function validateCommandEnvelope(data: unknown): CommandEnvelopeInput;
+export declare function validateWorkflowProfile(data: unknown): WorkflowProfileInput;
+export declare function validateExecutionContext(data: unknown): ExecutionContextInput;
+export declare function validatePlannerOutput(data: unknown): PlannerOutputInput;
+export declare function validateAgentOutput(data: unknown): AgentOutputInput;
+export declare function validateImplementerOutput(data: unknown): ImplementerOutputInput;
+export declare function validateReviewerOutput(data: unknown): ReviewerOutputInput;
+export declare function validateProductGraph(data: unknown): ProductGraphInput;
+export declare function validateKnowledgeEntity(data: unknown): KnowledgeEntityInput;
+export declare function validateDecision(data: unknown): DecisionInput;
+export declare function validateEvidence(data: unknown): EvidenceInput;
+export declare function validateCanonicalTaskCard(data: unknown): CanonicalTaskCardInput;
+export declare function validateProductEvent(data: unknown): ProductEventInput;