kiokuko-dsh 0.1.0

package/dist/model-tools/contracts.d.ts

@@ -0,0 +1,1297 @@
+import * as z from 'zod/v4';
+export declare const MODEL_TOOL_OPERATION_NAMES: readonly ["task_prepare", "task_answer", "enno_plan_submit", "enno_ideal_submit", "enno_advice_submit", "enno_advice_read", "enno_answer", "enno_work_report", "enno_verify_prepare", "enno_finish", "enno_meditation_submit", "curator_check", "curator_globalize", "memory_checkpoint"];
+export type ModelToolOperationName = (typeof MODEL_TOOL_OPERATION_NAMES)[number];
+export type ModelToolOwner = 'kiokuko-core';
+export type ModelToolExposure = 'host-only' | 'model-facing';
+export declare const taskPrepareInputSchema: z.ZodObject<{
+    soulRead: z.ZodLiteral<true>;
+    requestId: z.ZodString;
+    task: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    profileHints: z.ZodOptional<z.ZodObject<{
+        taskType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            build: "build";
+            debug: "debug";
+            research: "research";
+            review: "review";
+            devops: "devops";
+            writing: "writing";
+            analysis: "analysis";
+        }>>>;
+        target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        expected: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        constraints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    client: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodOptional<z.ZodString>;
+        version: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    maxContextChars: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const taskAnswerInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    questionId: z.ZodEnum<{
+        taskType: "taskType";
+        target: "target";
+        expected: "expected";
+        constraints: "constraints";
+    }>;
+    value: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    maxContextChars: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const curatorCheckInputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    workspace: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    includeUnready: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const curatorGlobalizeInputSchema: z.ZodObject<{
+    workspace: z.ZodString;
+    entryId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    confirmed: z.ZodLiteral<true>;
+}, z.core.$strict>;
+export declare const MODEL_TOOL_INPUT_SCHEMAS: {
+    readonly task_prepare: z.ZodObject<{
+        soulRead: z.ZodLiteral<true>;
+        requestId: z.ZodString;
+        task: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        profileHints: z.ZodOptional<z.ZodObject<{
+            taskType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                build: "build";
+                debug: "debug";
+                research: "research";
+                review: "review";
+                devops: "devops";
+                writing: "writing";
+                analysis: "analysis";
+            }>>>;
+            target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            expected: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            constraints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        client: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        maxContextChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly task_answer: z.ZodObject<{
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        questionId: z.ZodEnum<{
+            taskType: "taskType";
+            target: "target";
+            expected: "expected";
+            constraints: "constraints";
+        }>;
+        value: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        maxContextChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly enno_plan_submit: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        scope: z.ZodArray<z.ZodString>;
+        exclusions: z.ZodArray<z.ZodString>;
+        acceptanceCriteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        workPlan: z.ZodObject<{
+            objective: z.ZodString;
+            units: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                objective: z.ZodString;
+                scope: z.ZodArray<z.ZodString>;
+                dependencies: z.ZodArray<z.ZodString>;
+                skillNames: z.ZodArray<z.ZodString>;
+                expertRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodEnum<{
+                        "ui.interaction.v1": "ui.interaction.v1";
+                        "ui.async.v1": "ui.async.v1";
+                        "ui.forms.v1": "ui.forms.v1";
+                        "ui.accessibility.v1": "ui.accessibility.v1";
+                        "ui.layout.v1": "ui.layout.v1";
+                        "ui.safety.v1": "ui.safety.v1";
+                        "code.boundary.v1": "code.boundary.v1";
+                        "code.domain.v1": "code.domain.v1";
+                        "code.effects.v1": "code.effects.v1";
+                        "code.protocol.v1": "code.protocol.v1";
+                        "code.verification.v1": "code.verification.v1";
+                        "code.modeling.v1": "code.modeling.v1";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strict>>>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                focusedVerifiers: z.ZodArray<z.ZodObject<{
+                    cwd: z.ZodString;
+                    id: z.ZodString;
+                    kind: z.ZodEnum<{
+                        build: "build";
+                        custom: "custom";
+                        test: "test";
+                        typecheck: "typecheck";
+                        lint: "lint";
+                    }>;
+                    executable: z.ZodString;
+                    args: z.ZodArray<z.ZodString>;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>>;
+                routes: z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    docs: "docs";
+                    test: "test";
+                    ui: "ui";
+                    operations: "operations";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skillRequirements: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            purposes: z.ZodArray<z.ZodEnum<{
+                review: "review";
+                implementation: "implementation";
+                testing: "testing";
+                planning: "planning";
+                ui: "ui";
+                operations: "operations";
+            }>>;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+        finalVerifiers: z.ZodArray<z.ZodObject<{
+            cwd: z.ZodString;
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                build: "build";
+                custom: "custom";
+                test: "test";
+                typecheck: "typecheck";
+                lint: "lint";
+            }>;
+            executable: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        provenance: z.ZodObject<{
+            scope: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            exclusions: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            acceptanceCriteria: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            workPlan: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            skillSet: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            finalVerifiers: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            maxAttempts: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>;
+        recoveryAction: z.ZodOptional<z.ZodEnum<{
+            continue_same_plan: "continue_same_plan";
+            revise_plan: "revise_plan";
+        }>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly enno_ideal_submit: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        ideal: z.ZodObject<{
+            objective: z.ZodString;
+            principles: z.ZodArray<z.ZodString>;
+            skillContributions: z.ZodArray<z.ZodObject<{
+                skillName: z.ZodString;
+                contribution: z.ZodString;
+            }, z.core.$strict>>;
+            successSignals: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly enno_advice_submit: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        mutationRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        phase: z.ZodEnum<{
+            ideal: "ideal";
+            planning: "planning";
+            final_review: "final_review";
+        }>;
+        allowlistedContext: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            phase: z.ZodLiteral<"ideal">;
+            objective: z.ZodString;
+            constraints: z.ZodArray<z.ZodString>;
+            expectedOutcome: z.ZodString;
+            successSignals: z.ZodArray<z.ZodString>;
+            skillTrust: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    local: "local";
+                    imported_fresh: "imported_fresh";
+                    external_reference: "external_reference";
+                }>;
+                required: z.ZodBoolean;
+                trustStatus: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    available: "available";
+                    reference_only: "reference_only";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"planning">;
+            idealObjective: z.ZodString;
+            acceptanceCriteria: z.ZodArray<z.ZodString>;
+            planningConstraints: z.ZodArray<z.ZodString>;
+            skillAvailability: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    local: "local";
+                    imported_fresh: "imported_fresh";
+                    external_reference: "external_reference";
+                }>;
+                required: z.ZodBoolean;
+                trustStatus: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    available: "available";
+                    reference_only: "reference_only";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"final_review">;
+            workPlanSummary: z.ZodString;
+            acceptanceCriteria: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            workUnitOutcomes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                objective: z.ZodString;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                routes: z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    docs: "docs";
+                    test: "test";
+                    ui: "ui";
+                    operations: "operations";
+                }>>;
+                status: z.ZodEnum<{
+                    completed: "completed";
+                    failed: "failed";
+                    blocked: "blocked";
+                }>;
+                summary: z.ZodString;
+                mutated: z.ZodBoolean;
+                changedPaths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            changedPaths: z.ZodArray<z.ZodString>;
+            verifierEvidence: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    build: "build";
+                    custom: "custom";
+                    test: "test";
+                    typecheck: "typecheck";
+                    lint: "lint";
+                }>;
+                executable: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                directory: z.ZodString;
+                timeoutMs: z.ZodNumber;
+                status: z.ZodEnum<{
+                    timeout: "timeout";
+                    failed: "failed";
+                    passed: "passed";
+                    spawn_failed: "spawn_failed";
+                }>;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                signal: z.ZodNullable<z.ZodString>;
+                stdoutDigest: z.ZodString;
+                stderrDigest: z.ZodString;
+                stdoutPreview: z.ZodString;
+                stderrPreview: z.ZodString;
+                repositoryStatePolicyVersion: z.ZodNullable<z.ZodNumber>;
+                repositoryStateDigest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            freshnessMarker: z.ZodString;
+            evidenceSetDigest: z.ZodString;
+            repositoryStateDigest: z.ZodString;
+            evidenceFreshnessPolicyVersion: z.ZodNumber;
+        }, z.core.$strict>], "phase">;
+        contributions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            outcome: z.ZodLiteral<"completed">;
+            summary: z.ZodString;
+            recommendations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                statement: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            outcome: z.ZodEnum<{
+                timeout: "timeout";
+                unavailable: "unavailable";
+                failed: "failed";
+            }>;
+            reasonCode: z.ZodEnum<{
+                invalid_response: "invalid_response";
+                unsafe_output: "unsafe_output";
+                host_read_only_unavailable: "host_read_only_unavailable";
+                host_execution_failed: "host_execution_failed";
+                host_timeout: "host_timeout";
+            }>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>;
+    readonly enno_advice_read: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        advisoryRoundDigest: z.ZodString;
+    }, z.core.$strict>;
+    readonly enno_answer: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        action: z.ZodEnum<{
+            approve: "approve";
+            revise: "revise";
+            cancel: "cancel";
+        }>;
+        requestedChanges: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly enno_work_report: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        leaseToken: z.ZodOptional<z.ZodString>;
+        routeEpoch: z.ZodOptional<z.ZodNumber>;
+        workUnitId: z.ZodString;
+        result: z.ZodObject<{
+            outcome: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                blocked: "blocked";
+            }>;
+            summary: z.ZodString;
+            mutated: z.ZodBoolean;
+            changedPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly enno_verify_prepare: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+    }, z.core.$strict>;
+    readonly enno_finish: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        review: z.ZodObject<{
+            decision: z.ZodEnum<{
+                accept: "accept";
+                replan: "replan";
+            }>;
+            summary: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly enno_meditation_submit: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        meditation: z.ZodObject<{
+            summary: z.ZodString;
+            inspectedPaths: z.ZodArray<z.ZodString>;
+            deletionCandidates: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    function: "function";
+                    test: "test";
+                }>;
+                path: z.ZodString;
+                name: z.ZodString;
+                reason: z.ZodString;
+                evidence: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly curator_check: z.ZodObject<{
+        cwd: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        includeUnready: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly curator_globalize: z.ZodObject<{
+        workspace: z.ZodString;
+        entryId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly memory_checkpoint: z.ZodObject<{
+        cwd: z.ZodOptional<z.ZodString>;
+        memories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                fact: "fact";
+                decision: "decision";
+                lesson: "lesson";
+                preference: "preference";
+                reference: "reference";
+            }>;
+            title: z.ZodString;
+            body: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            scope: z.ZodDefault<z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>>;
+            retrievalScope: z.ZodOptional<z.ZodEnum<{
+                "project-only": "project-only";
+                ecosystem: "ecosystem";
+                global: "global";
+            }>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            memoryClass: z.ZodOptional<z.ZodEnum<{
+                preference: "preference";
+                reference: "reference";
+                "implementation-pattern": "implementation-pattern";
+                troubleshooting: "troubleshooting";
+                "tool-usage": "tool-usage";
+                "extension-usage": "extension-usage";
+                configuration: "configuration";
+                workflow: "workflow";
+                gotcha: "gotcha";
+            }>>;
+            applicability: z.ZodOptional<z.ZodObject<{
+                languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                frameworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                databases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            signals: z.ZodOptional<z.ZodObject<{
+                symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            portableReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        runId: z.ZodOptional<z.ZodString>;
+        deliveryId: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+        }>>;
+        feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            entryId: z.ZodString;
+            entryRevision: z.ZodNumber;
+            verdict: z.ZodEnum<{
+                helpful: "helpful";
+                irrelevant: "irrelevant";
+                stale: "stale";
+                conflicting: "conflicting";
+            }>;
+            comment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            changedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            errorSignatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                executable: z.ZodString;
+                classification: z.ZodOptional<z.ZodString>;
+                exitCode: z.ZodOptional<z.ZodNumber>;
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    passed: "passed";
+                }>;
+                digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                runner: z.ZodString;
+                target: z.ZodOptional<z.ZodString>;
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    passed: "passed";
+                }>;
+                digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            verification: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    stale: "stale";
+                    fresh: "fresh";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+};
+export interface ModelToolContract {
+    readonly name: ModelToolOperationName;
+    readonly owner: ModelToolOwner;
+    readonly exposure: ModelToolExposure;
+    readonly inputSchema: z.ZodType;
+    readonly hostOwnedFields: readonly string[];
+}
+export declare const MODEL_TOOL_CONTRACTS: readonly [{
+    readonly name: "task_prepare";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        soulRead: z.ZodLiteral<true>;
+        requestId: z.ZodString;
+        task: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        profileHints: z.ZodOptional<z.ZodObject<{
+            taskType: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                build: "build";
+                debug: "debug";
+                research: "research";
+                review: "review";
+                devops: "devops";
+                writing: "writing";
+                analysis: "analysis";
+            }>>>;
+            target: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            expected: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            constraints: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        client: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodOptional<z.ZodString>;
+            version: z.ZodOptional<z.ZodString>;
+            sessionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        maxContextChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["soulRead", "requestId", "task", "cwd", "profileHints", "capabilities", "client", "maxContextChars"];
+}, {
+    readonly name: "task_answer";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        questionId: z.ZodEnum<{
+            taskType: "taskType";
+            target: "target";
+            expected: "expected";
+            constraints: "constraints";
+        }>;
+        value: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+        maxContextChars: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["sessionId", "runId", "questionId", "value", "cwd", "capabilities", "maxContextChars"];
+}, {
+    readonly name: "enno_plan_submit";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        scope: z.ZodArray<z.ZodString>;
+        exclusions: z.ZodArray<z.ZodString>;
+        acceptanceCriteria: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        workPlan: z.ZodObject<{
+            objective: z.ZodString;
+            units: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                objective: z.ZodString;
+                scope: z.ZodArray<z.ZodString>;
+                dependencies: z.ZodArray<z.ZodString>;
+                skillNames: z.ZodArray<z.ZodString>;
+                expertRefs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodEnum<{
+                        "ui.interaction.v1": "ui.interaction.v1";
+                        "ui.async.v1": "ui.async.v1";
+                        "ui.forms.v1": "ui.forms.v1";
+                        "ui.accessibility.v1": "ui.accessibility.v1";
+                        "ui.layout.v1": "ui.layout.v1";
+                        "ui.safety.v1": "ui.safety.v1";
+                        "code.boundary.v1": "code.boundary.v1";
+                        "code.domain.v1": "code.domain.v1";
+                        "code.effects.v1": "code.effects.v1";
+                        "code.protocol.v1": "code.protocol.v1";
+                        "code.verification.v1": "code.verification.v1";
+                        "code.modeling.v1": "code.modeling.v1";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strict>>>;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                focusedVerifiers: z.ZodArray<z.ZodObject<{
+                    cwd: z.ZodString;
+                    id: z.ZodString;
+                    kind: z.ZodEnum<{
+                        build: "build";
+                        custom: "custom";
+                        test: "test";
+                        typecheck: "typecheck";
+                        lint: "lint";
+                    }>;
+                    executable: z.ZodString;
+                    args: z.ZodArray<z.ZodString>;
+                    timeoutMs: z.ZodNumber;
+                }, z.core.$strict>>;
+                routes: z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    docs: "docs";
+                    test: "test";
+                    ui: "ui";
+                    operations: "operations";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        skillRequirements: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            purposes: z.ZodArray<z.ZodEnum<{
+                review: "review";
+                implementation: "implementation";
+                testing: "testing";
+                planning: "planning";
+                ui: "ui";
+                operations: "operations";
+            }>>;
+            required: z.ZodBoolean;
+        }, z.core.$strict>>;
+        finalVerifiers: z.ZodArray<z.ZodObject<{
+            cwd: z.ZodString;
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                build: "build";
+                custom: "custom";
+                test: "test";
+                typecheck: "typecheck";
+                lint: "lint";
+            }>;
+            executable: z.ZodString;
+            args: z.ZodArray<z.ZodString>;
+            timeoutMs: z.ZodNumber;
+        }, z.core.$strict>>;
+        maxAttempts: z.ZodDefault<z.ZodNumber>;
+        provenance: z.ZodObject<{
+            scope: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            exclusions: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            acceptanceCriteria: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            workPlan: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            skillSet: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            finalVerifiers: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+            maxAttempts: z.ZodEnum<{
+                explicit_user: "explicit_user";
+                repository_evidence: "repository_evidence";
+                inferred: "inferred";
+            }>;
+        }, z.core.$strict>;
+        recoveryAction: z.ZodOptional<z.ZodEnum<{
+            continue_same_plan: "continue_same_plan";
+            revise_plan: "revise_plan";
+        }>>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey", "advisoryRoundDigest", "advisoryDisposition", "recoveryAction", "capabilities"];
+}, {
+    readonly name: "enno_ideal_submit";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        ideal: z.ZodObject<{
+            objective: z.ZodString;
+            principles: z.ZodArray<z.ZodString>;
+            skillContributions: z.ZodArray<z.ZodObject<{
+                skillName: z.ZodString;
+                contribution: z.ZodString;
+            }, z.core.$strict>>;
+            successSignals: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey", "advisoryRoundDigest", "advisoryDisposition"];
+}, {
+    readonly name: "enno_advice_submit";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        mutationRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        phase: z.ZodEnum<{
+            ideal: "ideal";
+            planning: "planning";
+            final_review: "final_review";
+        }>;
+        allowlistedContext: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            phase: z.ZodLiteral<"ideal">;
+            objective: z.ZodString;
+            constraints: z.ZodArray<z.ZodString>;
+            expectedOutcome: z.ZodString;
+            successSignals: z.ZodArray<z.ZodString>;
+            skillTrust: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    local: "local";
+                    imported_fresh: "imported_fresh";
+                    external_reference: "external_reference";
+                }>;
+                required: z.ZodBoolean;
+                trustStatus: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    available: "available";
+                    reference_only: "reference_only";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"planning">;
+            idealObjective: z.ZodString;
+            acceptanceCriteria: z.ZodArray<z.ZodString>;
+            planningConstraints: z.ZodArray<z.ZodString>;
+            skillAvailability: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                source: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    local: "local";
+                    imported_fresh: "imported_fresh";
+                    external_reference: "external_reference";
+                }>;
+                required: z.ZodBoolean;
+                trustStatus: z.ZodEnum<{
+                    unavailable: "unavailable";
+                    available: "available";
+                    reference_only: "reference_only";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"final_review">;
+            workPlanSummary: z.ZodString;
+            acceptanceCriteria: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+            workUnitOutcomes: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                objective: z.ZodString;
+                acceptanceCriteria: z.ZodArray<z.ZodString>;
+                routes: z.ZodArray<z.ZodEnum<{
+                    code: "code";
+                    docs: "docs";
+                    test: "test";
+                    ui: "ui";
+                    operations: "operations";
+                }>>;
+                status: z.ZodEnum<{
+                    completed: "completed";
+                    failed: "failed";
+                    blocked: "blocked";
+                }>;
+                summary: z.ZodString;
+                mutated: z.ZodBoolean;
+                changedPaths: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            changedPaths: z.ZodArray<z.ZodString>;
+            verifierEvidence: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    build: "build";
+                    custom: "custom";
+                    test: "test";
+                    typecheck: "typecheck";
+                    lint: "lint";
+                }>;
+                executable: z.ZodString;
+                args: z.ZodArray<z.ZodString>;
+                directory: z.ZodString;
+                timeoutMs: z.ZodNumber;
+                status: z.ZodEnum<{
+                    timeout: "timeout";
+                    failed: "failed";
+                    passed: "passed";
+                    spawn_failed: "spawn_failed";
+                }>;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                signal: z.ZodNullable<z.ZodString>;
+                stdoutDigest: z.ZodString;
+                stderrDigest: z.ZodString;
+                stdoutPreview: z.ZodString;
+                stderrPreview: z.ZodString;
+                repositoryStatePolicyVersion: z.ZodNullable<z.ZodNumber>;
+                repositoryStateDigest: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            freshnessMarker: z.ZodString;
+            evidenceSetDigest: z.ZodString;
+            repositoryStateDigest: z.ZodString;
+            evidenceFreshnessPolicyVersion: z.ZodNumber;
+        }, z.core.$strict>], "phase">;
+        contributions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            outcome: z.ZodLiteral<"completed">;
+            summary: z.ZodString;
+            recommendations: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            risks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            evidence: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                statement: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            outcome: z.ZodEnum<{
+                timeout: "timeout";
+                unavailable: "unavailable";
+                failed: "failed";
+            }>;
+            reasonCode: z.ZodEnum<{
+                invalid_response: "invalid_response";
+                unsafe_output: "unsafe_output";
+                host_read_only_unavailable: "host_read_only_unavailable";
+                host_execution_failed: "host_execution_failed";
+                host_timeout: "host_timeout";
+            }>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "mutationRevision", "idempotencyKey", "phase", "allowlistedContext", "contributions"];
+}, {
+    readonly name: "enno_advice_read";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        advisoryRoundDigest: z.ZodString;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "advisoryRoundDigest"];
+}, {
+    readonly name: "enno_answer";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        action: z.ZodEnum<{
+            approve: "approve";
+            revise: "revise";
+            cancel: "cancel";
+        }>;
+        requestedChanges: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey", "action", "requestedChanges"];
+}, {
+    readonly name: "enno_work_report";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        leaseToken: z.ZodOptional<z.ZodString>;
+        routeEpoch: z.ZodOptional<z.ZodNumber>;
+        workUnitId: z.ZodString;
+        result: z.ZodObject<{
+            outcome: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                blocked: "blocked";
+            }>;
+            summary: z.ZodString;
+            mutated: z.ZodBoolean;
+            changedPaths: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey", "leaseToken", "routeEpoch", "workUnitId"];
+}, {
+    readonly name: "enno_verify_prepare";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey"];
+}, {
+    readonly name: "enno_finish";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        advisoryRoundDigest: z.ZodOptional<z.ZodString>;
+        advisoryDisposition: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            slotId: z.ZodPipe<z.ZodString, z.ZodEnum<{
+                [x: string]: string;
+            }>>;
+            disposition: z.ZodEnum<{
+                unavailable: "unavailable";
+                adopted: "adopted";
+                not_adopted: "not_adopted";
+            }>;
+            rationale: z.ZodString;
+        }, z.core.$strict>>>;
+        review: z.ZodObject<{
+            decision: z.ZodEnum<{
+                accept: "accept";
+                replan: "replan";
+            }>;
+            summary: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey", "advisoryRoundDigest", "advisoryDisposition"];
+}, {
+    readonly name: "enno_meditation_submit";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        runId: z.ZodString;
+        workspace: z.ZodOptional<z.ZodString>;
+        orchestrationId: z.ZodOptional<z.ZodString>;
+        resumeToken: z.ZodOptional<z.ZodString>;
+        expectedRevision: z.ZodNumber;
+        idempotencyKey: z.ZodString;
+        meditation: z.ZodObject<{
+            summary: z.ZodString;
+            inspectedPaths: z.ZodArray<z.ZodString>;
+            deletionCandidates: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    function: "function";
+                    test: "test";
+                }>;
+                path: z.ZodString;
+                name: z.ZodString;
+                reason: z.ZodString;
+                evidence: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["runId", "workspace", "orchestrationId", "resumeToken", "expectedRevision", "idempotencyKey"];
+}, {
+    readonly name: "curator_check";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        cwd: z.ZodOptional<z.ZodString>;
+        workspace: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        includeUnready: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["cwd", "workspace"];
+}, {
+    readonly name: "curator_globalize";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "host-only";
+    readonly inputSchema: z.ZodObject<{
+        workspace: z.ZodString;
+        entryId: z.ZodString;
+        expectedRevision: z.ZodNumber;
+        confirmed: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["workspace", "entryId", "expectedRevision", "confirmed"];
+}, {
+    readonly name: "memory_checkpoint";
+    readonly owner: "kiokuko-core";
+    readonly exposure: "model-facing";
+    readonly inputSchema: z.ZodObject<{
+        cwd: z.ZodOptional<z.ZodString>;
+        memories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                fact: "fact";
+                decision: "decision";
+                lesson: "lesson";
+                preference: "preference";
+                reference: "reference";
+            }>;
+            title: z.ZodString;
+            body: z.ZodString;
+            summary: z.ZodOptional<z.ZodString>;
+            scope: z.ZodDefault<z.ZodEnum<{
+                global: "global";
+                project: "project";
+            }>>;
+            retrievalScope: z.ZodOptional<z.ZodEnum<{
+                "project-only": "project-only";
+                ecosystem: "ecosystem";
+                global: "global";
+            }>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            confidence: z.ZodDefault<z.ZodNumber>;
+            memoryClass: z.ZodOptional<z.ZodEnum<{
+                preference: "preference";
+                reference: "reference";
+                "implementation-pattern": "implementation-pattern";
+                troubleshooting: "troubleshooting";
+                "tool-usage": "tool-usage";
+                "extension-usage": "extension-usage";
+                configuration: "configuration";
+                workflow: "workflow";
+                gotcha: "gotcha";
+            }>>;
+            applicability: z.ZodOptional<z.ZodObject<{
+                languages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                frameworks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    version: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>>;
+                databases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                runtimes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                platforms: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            signals: z.ZodOptional<z.ZodObject<{
+                symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                errors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                commands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strict>>;
+            portableReason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        runId: z.ZodOptional<z.ZodString>;
+        deliveryId: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            completed: "completed";
+            failed: "failed";
+            cancelled: "cancelled";
+            interrupted: "interrupted";
+        }>>;
+        feedback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            entryId: z.ZodString;
+            entryRevision: z.ZodNumber;
+            verdict: z.ZodEnum<{
+                helpful: "helpful";
+                irrelevant: "irrelevant";
+                stale: "stale";
+                conflicting: "conflicting";
+            }>;
+            comment: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        evidence: z.ZodOptional<z.ZodObject<{
+            changedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            errorSignatures: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                executable: z.ZodString;
+                classification: z.ZodOptional<z.ZodString>;
+                exitCode: z.ZodOptional<z.ZodNumber>;
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    passed: "passed";
+                }>;
+                digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            tests: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                runner: z.ZodString;
+                target: z.ZodOptional<z.ZodString>;
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    passed: "passed";
+                }>;
+                digest: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            verification: z.ZodOptional<z.ZodObject<{
+                outcome: z.ZodEnum<{
+                    unknown: "unknown";
+                    failed: "failed";
+                    stale: "stale";
+                    fresh: "fresh";
+                }>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    readonly hostOwnedFields: readonly ["cwd", "runId", "deliveryId"];
+}];
+//# sourceMappingURL=contracts.d.ts.map