@anhlp/alp-protocol 0.0.0-beta.1

package/dist/contract-v1.d.ts

@@ -0,0 +1,4171 @@
+export namespace METHODS_V1 {
+    let $schema: string;
+    let $id: string;
+    let protocolVersion: number;
+    namespace errors {
+        let parseError: number;
+        let invalidRequest: number;
+        let methodNotFound: number;
+        let invalidParams: number;
+        let failed: number;
+        let notFound: number;
+        let forbidden: number;
+        let conflict: number;
+        let unavailable: number;
+        let protocol: number;
+    }
+    let capabilities: {
+        "attach.after": string;
+        "prompt.receipts": string;
+        "extension.methods": string;
+        team: string;
+        task: string;
+        library: string;
+        "settings.language": string;
+    };
+    let methods: {
+        "assignment.recall": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                    alternatives: string[];
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    assignmentId: {
+                        type: string;
+                    };
+                    taskId: {
+                        type: string;
+                    };
+                    projectRoot: {
+                        type: string;
+                    };
+                    question: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    assignmentId: {
+                        type: string;
+                    };
+                    agent: {
+                        type: string;
+                    };
+                    taskId: {
+                        type: string;
+                    };
+                    finishedAt: {
+                        type: string;
+                    };
+                    answer: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "board.list": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    pins: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "catalog.get": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    models: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    modes: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    thinkingOptions: {};
+                    defaultModel: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "daemon.hello": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    protocolVersion: {
+                        const: number;
+                    };
+                    client: {
+                        type: string;
+                        properties: {
+                            name: {
+                                type: string;
+                            };
+                            version: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    capabilities: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    protocolVersion: {
+                        const: number;
+                    };
+                    daemonVersion: {
+                        type: string;
+                    };
+                    pid: {
+                        type: string;
+                    };
+                    capabilities: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "daemon.pause": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    runtime: {
+                        enum: string[];
+                    };
+                    now: {
+                        type: string;
+                    };
+                    reason: {
+                        type: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                $ref: string;
+            };
+        };
+        "daemon.pauses": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                $ref: string;
+            };
+        };
+        "daemon.resume": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    runtime: {
+                        enum: string[];
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                $ref: string;
+            };
+        };
+        "daemon.shutdown": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+        "daemon.status": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    pid: {
+                        type: string;
+                    };
+                    startedAt: {
+                        type: string;
+                    };
+                    version: {
+                        type: string;
+                    };
+                    protocolVersion: {
+                        type: string;
+                    };
+                    sessions: {
+                        type: string;
+                    };
+                    questions: {
+                        type: string;
+                    };
+                    previousExit: {
+                        type: string;
+                        properties: {
+                            kind: {
+                                enum: string[];
+                            };
+                            at: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    persistence: {
+                        type: string;
+                    };
+                    health: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "daemon.usage": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    refresh: {
+                        type: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    providers: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "extension.register": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    method: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    registered: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "extension.unregister": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    method: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    unregistered: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.delete": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    selector: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    name: {
+                        $ref: string;
+                    };
+                    scope: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    revision: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    removed: {
+                        const: boolean;
+                    };
+                    now: {
+                        enum: string[];
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.duplicate": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    selector: string;
+                    reads: string[];
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    from: {
+                        $ref: string;
+                    };
+                    to: {
+                        $ref: string;
+                    };
+                    scope: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    revision: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.get": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                    reads: string[];
+                };
+                idempotent: boolean;
+                redacts: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    name: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    scope: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    name: {
+                        type: string;
+                    };
+                    source: {
+                        $ref: string;
+                    };
+                    overrides: {
+                        $ref: string;
+                    };
+                    content: {
+                        type: string;
+                    };
+                    revision: {
+                        $ref: string;
+                    };
+                    usedBy: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    librarySkills: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                    secrets: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.list": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                    reads: string[];
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string[];
+                    };
+                    entries: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.models": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    models: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                id: {
+                                    type: string;
+                                };
+                                label: {
+                                    type: string;
+                                };
+                                efforts: {
+                                    type: string;
+                                    items: {
+                                        type: string;
+                                    };
+                                };
+                                effort: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.rename": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    selector: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    from: {
+                        $ref: string;
+                    };
+                    to: {
+                        $ref: string;
+                    };
+                    scope: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    revision: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.save": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    selector: string;
+                };
+                idempotent: string;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    kind: {
+                        $ref: string;
+                    };
+                    name: {
+                        $ref: string;
+                    };
+                    scope: {
+                        $ref: string;
+                    };
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    content: {
+                        type: string;
+                    };
+                    revision: {
+                        $ref: string;
+                    };
+                    sync: {
+                        enum: string[];
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    revision: {
+                        $ref: string;
+                    };
+                    syncedProjects: {
+                        type: string;
+                        minimum: number;
+                    };
+                    syncErrors: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "library.skills.set": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                };
+                writes: string[];
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    agent: {
+                        $ref: string;
+                    };
+                    skills: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                        maxItems: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    skills: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "question.answer": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    prefix: boolean;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    questionId: {
+                        type: string;
+                    };
+                    text: {
+                        type: string;
+                    };
+                    dismiss: {
+                        type: string;
+                    };
+                    reason: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    questionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "question.list": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    questions: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.archive": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    archived: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.attach": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    replay: {
+                        type: string;
+                    };
+                    after: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                    cursor: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    reset: {
+                        const: boolean;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.close": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.configure": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    mode: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.create": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+                risks: string[];
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                        pattern: string;
+                    };
+                    spec: {
+                        $ref: string;
+                    };
+                    history: {
+                        enum: string[];
+                    };
+                    delegation: {
+                        type: string;
+                    };
+                    resume: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                    attached: {
+                        type: string;
+                    };
+                    resumed: {
+                        const: boolean;
+                    };
+                    durable: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.get": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.interrupt": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.list": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string;
+                    };
+                    rootsOnly: {
+                        type: string;
+                    };
+                    includeClosed: {
+                        type: string;
+                    };
+                    includeArchived: {
+                        type: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    sessions: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.log": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    rootId: {
+                        type: string;
+                    };
+                    entries: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.message": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    text: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.preview": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    spec: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    preview: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.prompt": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: string;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    clientMessageId: {
+                        type: string;
+                    };
+                    delivery: {
+                        enum: string[];
+                    };
+                    content: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                type: {
+                                    type: string;
+                                };
+                                text: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    outcome: {
+                        enum: string[];
+                    };
+                    error: {
+                        $ref: string;
+                    };
+                    duplicate: {
+                        type: string;
+                    };
+                    durable: {
+                        type: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.release": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    closed: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.rename": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                    title: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                        pattern: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    session: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "session.status": {
+            "x-alp": {
+                effect: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    sessionId: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    status: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "settings.language.get": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {};
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                $ref: string;
+            };
+        };
+        "settings.language.set": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                };
+                writes: string[];
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    language: {
+                        anyOf: ({
+                            type: string;
+                            minLength: number;
+                            maxLength: number;
+                            pattern: string;
+                        } | {
+                            type: string;
+                            minLength?: undefined;
+                            maxLength?: undefined;
+                            pattern?: undefined;
+                        })[];
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                $ref: string;
+            };
+        };
+        "task.create": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                writes: string[];
+                idempotent: string;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    title: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                        pattern: string;
+                    };
+                    priority: {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                    };
+                    requestId: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    id: {
+                        $ref: string;
+                    };
+                    duplicate: {
+                        const: boolean;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "task.gate.resolve": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                writes: string[];
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    id: {
+                        $ref: string;
+                    };
+                    gate: {
+                        type: string;
+                        minLength: number;
+                        maxLength: number;
+                    };
+                    note: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    ifRev: {
+                        type: string;
+                        minimum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    id: {
+                        $ref: string;
+                    };
+                    status: {
+                        type: string;
+                    };
+                    rev: {
+                        type: string;
+                        minimum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "task.list": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        $ref: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string;
+                    };
+                    tasks: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                    unreadable: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                file: {
+                                    type: string;
+                                };
+                                error: {
+                                    type: string;
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    revision: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "task.update": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                };
+                writes: string[];
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        $ref: string;
+                    };
+                    id: {
+                        $ref: string;
+                    };
+                    action: {
+                        enum: string[];
+                    };
+                    note: {
+                        type: string;
+                        maxLength: number;
+                    };
+                    ifRev: {
+                        type: string;
+                        minimum: number;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    id: {
+                        $ref: string;
+                    };
+                    status: {
+                        type: string;
+                    };
+                    rev: {
+                        type: string;
+                        minimum: number;
+                    };
+                    landed: {
+                        type: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        "team.list": {
+            "x-alp": {
+                effect: string;
+                capability: string;
+                scope: {
+                    kind: string;
+                    param: string;
+                    required: boolean;
+                    reads: string[];
+                };
+                idempotent: boolean;
+            };
+            params: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        $ref: string;
+                    };
+                };
+                required: never[];
+                additionalProperties: boolean;
+            };
+            result: {
+                type: string;
+                properties: {
+                    projectRoot: {
+                        type: string[];
+                    };
+                    teams: {
+                        type: string;
+                        items: {
+                            $ref: string;
+                        };
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+    };
+    namespace $defs {
+        export namespace error {
+            let type: string;
+            namespace properties {
+                namespace code {
+                    let type_1: string;
+                    export { type_1 as type };
+                }
+                namespace message {
+                    let type_2: string;
+                    export { type_2 as type };
+                }
+                let data: {};
+            }
+            let required: string[];
+            let additionalProperties: boolean;
+        }
+        export namespace session {
+            let type_3: string;
+            export { type_3 as type };
+            export namespace properties_1 {
+                namespace id {
+                    let type_4: string;
+                    export { type_4 as type };
+                }
+                namespace projectRoot {
+                    let type_5: string;
+                    export { type_5 as type };
+                }
+                namespace agent {
+                    let type_6: string;
+                    export { type_6 as type };
+                }
+                namespace runtime {
+                    let _enum: string[];
+                    export { _enum as enum };
+                }
+                namespace model {
+                    let type_7: string;
+                    export { type_7 as type };
+                }
+                namespace mode {
+                    let type_8: string;
+                    export { type_8 as type };
+                }
+                namespace thinking {
+                    let type_9: string;
+                    export { type_9 as type };
+                }
+                namespace workflow {
+                    let type_10: string;
+                    export { type_10 as type };
+                    export namespace properties_2 {
+                        export namespace mode_1 {
+                            let type_11: string;
+                            export { type_11 as type };
+                        }
+                        export { mode_1 as mode };
+                        export namespace maxPeers {
+                            let type_12: string;
+                            export { type_12 as type };
+                        }
+                        export namespace supervisor {
+                            let type_13: string;
+                            export { type_13 as type };
+                        }
+                    }
+                    export { properties_2 as properties };
+                    let required_1: string[];
+                    export { required_1 as required };
+                    let additionalProperties_1: boolean;
+                    export { additionalProperties_1 as additionalProperties };
+                }
+                namespace threadId {
+                    let type_14: string;
+                    export { type_14 as type };
+                }
+                namespace persistent {
+                    let type_15: string;
+                    export { type_15 as type };
+                }
+                namespace busy {
+                    let type_16: string;
+                    export { type_16 as type };
+                }
+                namespace parentId {
+                    let type_17: string;
+                    export { type_17 as type };
+                }
+                namespace toolCallId {
+                    let type_18: string;
+                    export { type_18 as type };
+                }
+                namespace activeTurnId {
+                    let type_19: string;
+                    export { type_19 as type };
+                }
+                namespace parked {
+                    let type_20: string;
+                    export { type_20 as type };
+                }
+                namespace instructionsSha {
+                    let type_21: string;
+                    export { type_21 as type };
+                }
+                namespace teamLabel {
+                    let type_22: string;
+                    export { type_22 as type };
+                }
+            }
+            export { properties_1 as properties };
+            let required_2: string[];
+            export { required_2 as required };
+            let additionalProperties_2: boolean;
+            export { additionalProperties_2 as additionalProperties };
+        }
+        export namespace assignment {
+            let type_23: string;
+            export { type_23 as type };
+            export namespace properties_3 {
+                export namespace id_1 {
+                    let type_24: string;
+                    export { type_24 as type };
+                }
+                export { id_1 as id };
+                export namespace agent_1 {
+                    let type_25: string;
+                    export { type_25 as type };
+                }
+                export { agent_1 as agent };
+                export namespace mode_2 {
+                    let type_26: string;
+                    export { type_26 as type };
+                }
+                export { mode_2 as mode };
+                export namespace status {
+                    let type_27: string;
+                    export { type_27 as type };
+                }
+                export namespace startedAt {
+                    let type_28: string;
+                    export { type_28 as type };
+                }
+                export namespace worktree {
+                    let type_29: string;
+                    export { type_29 as type };
+                    export namespace properties_4 {
+                        namespace branch {
+                            let type_30: string;
+                            export { type_30 as type };
+                        }
+                        namespace path {
+                            let type_31: string;
+                            export { type_31 as type };
+                        }
+                    }
+                    export { properties_4 as properties };
+                    let required_3: string[];
+                    export { required_3 as required };
+                    let additionalProperties_3: boolean;
+                    export { additionalProperties_3 as additionalProperties };
+                }
+            }
+            export { properties_3 as properties };
+            let required_4: string[];
+            export { required_4 as required };
+            let additionalProperties_4: boolean;
+            export { additionalProperties_4 as additionalProperties };
+        }
+        export namespace mail {
+            let type_32: string;
+            export { type_32 as type };
+            export namespace properties_5 {
+                export namespace id_2 {
+                    let type_33: string;
+                    export { type_33 as type };
+                }
+                export { id_2 as id };
+                export namespace kind {
+                    let _enum_1: string[];
+                    export { _enum_1 as enum };
+                }
+                export namespace from {
+                    let type_34: string;
+                    export { type_34 as type };
+                }
+                export namespace assignment_1 {
+                    let type_35: string;
+                    export { type_35 as type };
+                }
+                export { assignment_1 as assignment };
+                export namespace body {
+                    let type_36: string;
+                    export { type_36 as type };
+                }
+                export namespace replyTo {
+                    let type_37: string;
+                    export { type_37 as type };
+                }
+                export namespace result {
+                    let type_38: string;
+                    export { type_38 as type };
+                }
+                export namespace redelivered {
+                    let type_39: string;
+                    export { type_39 as type };
+                }
+            }
+            export { properties_5 as properties };
+            let required_5: string[];
+            export { required_5 as required };
+            let additionalProperties_5: boolean;
+            export { additionalProperties_5 as additionalProperties };
+        }
+        export namespace pin {
+            let type_40: string;
+            export { type_40 as type };
+            export namespace properties_6 {
+                export namespace id_3 {
+                    let type_41: string;
+                    export { type_41 as type };
+                }
+                export { id_3 as id };
+                export namespace project {
+                    let type_42: string;
+                    export { type_42 as type };
+                }
+                export namespace kind_1 {
+                    let _enum_2: string[];
+                    export { _enum_2 as enum };
+                }
+                export { kind_1 as kind };
+                export namespace body_1 {
+                    let type_43: string;
+                    export { type_43 as type };
+                }
+                export { body_1 as body };
+                export namespace paths {
+                    let type_44: string;
+                    export { type_44 as type };
+                    export namespace items {
+                        let type_45: string;
+                        export { type_45 as type };
+                    }
+                }
+                export namespace agent_2 {
+                    let type_46: string;
+                    export { type_46 as type };
+                }
+                export { agent_2 as agent };
+                export namespace sessionId {
+                    let type_47: string;
+                    export { type_47 as type };
+                }
+                export namespace rootId {
+                    let type_48: string;
+                    export { type_48 as type };
+                }
+                export namespace at {
+                    let type_49: string;
+                    export { type_49 as type };
+                }
+                export namespace released {
+                    let type_50: string;
+                    export { type_50 as type };
+                }
+                export namespace task {
+                    let type_51: string;
+                    export { type_51 as type };
+                }
+            }
+            export { properties_6 as properties };
+            let required_6: string[];
+            export { required_6 as required };
+            let additionalProperties_6: boolean;
+            export { additionalProperties_6 as additionalProperties };
+        }
+        export namespace question {
+            let type_52: string;
+            export { type_52 as type };
+            export namespace properties_7 {
+                export namespace id_4 {
+                    let type_53: string;
+                    export { type_53 as type };
+                }
+                export { id_4 as id };
+                export namespace sessionId_1 {
+                    let type_54: string;
+                    export { type_54 as type };
+                }
+                export { sessionId_1 as sessionId };
+                export namespace rootId_1 {
+                    let type_55: string;
+                    export { type_55 as type };
+                }
+                export { rootId_1 as rootId };
+                export namespace agent_3 {
+                    let type_56: string;
+                    export { type_56 as type };
+                }
+                export { agent_3 as agent };
+                export namespace body_2 {
+                    let type_57: string;
+                    export { type_57 as type };
+                }
+                export { body_2 as body };
+                export namespace options {
+                    let type_58: string;
+                    export { type_58 as type };
+                    export namespace items_1 {
+                        let type_59: string;
+                        export { type_59 as type };
+                    }
+                    export { items_1 as items };
+                }
+                export namespace askedAt {
+                    let type_60: string;
+                    export { type_60 as type };
+                }
+            }
+            export { properties_7 as properties };
+            let required_7: string[];
+            export { required_7 as required };
+            let additionalProperties_7: boolean;
+            export { additionalProperties_7 as additionalProperties };
+        }
+        export namespace spec {
+            let type_61: string;
+            export { type_61 as type };
+            export namespace properties_8 {
+                export namespace cwd {
+                    let type_62: string;
+                    export { type_62 as type };
+                }
+                export namespace agent_4 {
+                    let type_63: string;
+                    export { type_63 as type };
+                }
+                export { agent_4 as agent };
+                export namespace model_1 {
+                    let type_64: string;
+                    export { type_64 as type };
+                }
+                export { model_1 as model };
+                export namespace mode_3 {
+                    let type_65: string;
+                    export { type_65 as type };
+                }
+                export { mode_3 as mode };
+                export namespace thinking_1 {
+                    let type_66: string;
+                    export { type_66 as type };
+                }
+                export { thinking_1 as thinking };
+                export namespace persist {
+                    let type_67: string;
+                    export { type_67 as type };
+                }
+                export namespace restore {
+                    let type_68: string;
+                    export { type_68 as type };
+                }
+            }
+            export { properties_8 as properties };
+            let required_8: string[];
+            export { required_8 as required };
+            let additionalProperties_8: boolean;
+            export { additionalProperties_8 as additionalProperties };
+        }
+        export namespace item {
+            let anyOf: {
+                $ref: string;
+            }[];
+        }
+        export namespace event {
+            let anyOf_1: {
+                $ref: string;
+            }[];
+            export { anyOf_1 as anyOf };
+        }
+        export namespace envelope {
+            let type_69: string;
+            export { type_69 as type };
+            export namespace properties_9 {
+                export namespace sessionId_2 {
+                    let type_70: string;
+                    export { type_70 as type };
+                }
+                export { sessionId_2 as sessionId };
+                export namespace epoch {
+                    let type_71: string;
+                    export { type_71 as type };
+                }
+                export namespace seq {
+                    let type_72: string;
+                    export { type_72 as type };
+                    export let minimum: number;
+                    export let maximum: number;
+                }
+                export namespace ts {
+                    let type_73: string;
+                    export { type_73 as type };
+                }
+                export namespace event_1 {
+                    let $ref: string;
+                }
+                export { event_1 as event };
+                export namespace cursor {
+                    let type_74: string;
+                    export { type_74 as type };
+                    let minimum_1: number;
+                    export { minimum_1 as minimum };
+                    let maximum_1: number;
+                    export { maximum_1 as maximum };
+                }
+            }
+            export { properties_9 as properties };
+            let required_9: string[];
+            export { required_9 as required };
+            let additionalProperties_9: boolean;
+            export { additionalProperties_9 as additionalProperties };
+        }
+        export namespace request {
+            let type_75: string;
+            export { type_75 as type };
+            export namespace properties_10 {
+                export namespace jsonrpc {
+                    let _const: string;
+                    export { _const as const };
+                }
+                export namespace id_5 {
+                    let anyOf_2: ({
+                        type: string;
+                        maxLength: number;
+                        minimum?: undefined;
+                        maximum?: undefined;
+                    } | {
+                        type: string;
+                        minimum: number;
+                        maximum: number;
+                        maxLength?: undefined;
+                    })[];
+                    export { anyOf_2 as anyOf };
+                }
+                export { id_5 as id };
+                export namespace method {
+                    let type_76: string;
+                    export { type_76 as type };
+                }
+                export namespace params {
+                    let type_77: string;
+                    export { type_77 as type };
+                }
+            }
+            export { properties_10 as properties };
+            let required_10: string[];
+            export { required_10 as required };
+            let additionalProperties_10: boolean;
+            export { additionalProperties_10 as additionalProperties };
+        }
+        export namespace response {
+            let oneOf: ({
+                type: string;
+                properties: {
+                    jsonrpc: {
+                        const: string;
+                    };
+                    id: {
+                        anyOf: ({
+                            type: string;
+                            maxLength: number;
+                            minimum?: undefined;
+                            maximum?: undefined;
+                        } | {
+                            type: string;
+                            minimum: number;
+                            maximum: number;
+                            maxLength?: undefined;
+                        } | {
+                            type: string;
+                            maxLength?: undefined;
+                            minimum?: undefined;
+                            maximum?: undefined;
+                        })[];
+                    };
+                    result: {};
+                    error?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    jsonrpc: {
+                        const: string;
+                    };
+                    id: {
+                        anyOf: ({
+                            type: string;
+                            maxLength: number;
+                            minimum?: undefined;
+                            maximum?: undefined;
+                        } | {
+                            type: string;
+                            minimum: number;
+                            maximum: number;
+                            maxLength?: undefined;
+                        } | {
+                            type: string;
+                            maxLength?: undefined;
+                            minimum?: undefined;
+                            maximum?: undefined;
+                        })[];
+                    };
+                    error: {
+                        $ref: string;
+                    };
+                    result?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            })[];
+        }
+        export namespace notification {
+            let type_78: string;
+            export { type_78 as type };
+            export namespace properties_11 {
+                export namespace jsonrpc_1 {
+                    let _const_1: string;
+                    export { _const_1 as const };
+                }
+                export { jsonrpc_1 as jsonrpc };
+                export namespace method_1 {
+                    let _const_2: string;
+                    export { _const_2 as const };
+                }
+                export { method_1 as method };
+                export namespace params_1 {
+                    let $ref_1: string;
+                    export { $ref_1 as $ref };
+                }
+                export { params_1 as params };
+            }
+            export { properties_11 as properties };
+            let required_11: string[];
+            export { required_11 as required };
+            let additionalProperties_11: boolean;
+            export { additionalProperties_11 as additionalProperties };
+        }
+        export namespace knownEvent {
+            let oneOf_1: ({
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    session: {
+                        $ref: string;
+                    };
+                    cwd: {
+                        type: string;
+                    };
+                    effective: {
+                        type: string;
+                        properties: {
+                            model: {
+                                type: string;
+                            };
+                            thinking: {
+                                type: string;
+                            };
+                        };
+                        required: string[];
+                        additionalProperties: boolean;
+                    };
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    session: {
+                        $ref: string;
+                    };
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    error: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    clientMessageId: {
+                        type: string;
+                    };
+                    result: {
+                        enum: string[];
+                    };
+                    turnId: {
+                        type: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    clientMessageId: {
+                        type: string;
+                    };
+                    error: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    turnId: {
+                        type: string;
+                    };
+                    origin: {
+                        enum: string[];
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    turnId: {
+                        type: string;
+                    };
+                    state: {
+                        enum: string[];
+                    };
+                    error: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    origin?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    item: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    mail: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    assignment: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    question: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    questionId: {
+                        type: string;
+                    };
+                    outcome: {
+                        enum: string[];
+                    };
+                    answer: {
+                        type: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    pin?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    pin: {
+                        $ref: string;
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pinId?: undefined;
+                    reason?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    type: {
+                        const: string;
+                    };
+                    pinId: {
+                        type: string;
+                    };
+                    reason: {
+                        enum: string[];
+                    };
+                    session?: undefined;
+                    cwd?: undefined;
+                    effective?: undefined;
+                    error?: undefined;
+                    clientMessageId?: undefined;
+                    result?: undefined;
+                    turnId?: undefined;
+                    origin?: undefined;
+                    state?: undefined;
+                    item?: undefined;
+                    mail?: undefined;
+                    assignment?: undefined;
+                    question?: undefined;
+                    questionId?: undefined;
+                    outcome?: undefined;
+                    answer?: undefined;
+                    pin?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            })[];
+            export { oneOf_1 as oneOf };
+        }
+        export namespace unknownEvent {
+            let type_79: string;
+            export { type_79 as type };
+            export namespace properties_12 {
+                export namespace type_80 {
+                    let type_81: string;
+                    export { type_81 as type };
+                    export namespace not {
+                        let _enum_3: string[];
+                        export { _enum_3 as enum };
+                    }
+                }
+                export { type_80 as type };
+            }
+            export { properties_12 as properties };
+            let required_12: string[];
+            export { required_12 as required };
+            let additionalProperties_12: boolean;
+            export { additionalProperties_12 as additionalProperties };
+        }
+        export namespace knownItem {
+            let oneOf_2: ({
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    text: {
+                        type: string;
+                    };
+                    clientMessageId: {
+                        type: string;
+                    };
+                    level?: undefined;
+                    status?: undefined;
+                    trigger?: undefined;
+                    preTokens?: undefined;
+                    postTokens?: undefined;
+                    items?: undefined;
+                    callId?: undefined;
+                    name?: undefined;
+                    error?: undefined;
+                    detail?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    text: {
+                        type: string;
+                    };
+                    clientMessageId?: undefined;
+                    level?: undefined;
+                    status?: undefined;
+                    trigger?: undefined;
+                    preTokens?: undefined;
+                    postTokens?: undefined;
+                    items?: undefined;
+                    callId?: undefined;
+                    name?: undefined;
+                    error?: undefined;
+                    detail?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    level: {
+                        enum: string[];
+                    };
+                    text: {
+                        type: string;
+                    };
+                    clientMessageId?: undefined;
+                    status?: undefined;
+                    trigger?: undefined;
+                    preTokens?: undefined;
+                    postTokens?: undefined;
+                    items?: undefined;
+                    callId?: undefined;
+                    name?: undefined;
+                    error?: undefined;
+                    detail?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    status: {
+                        enum: string[];
+                    };
+                    trigger: {
+                        type: string;
+                    };
+                    preTokens: {
+                        type: string;
+                    };
+                    postTokens: {
+                        type: string;
+                    };
+                    text?: undefined;
+                    clientMessageId?: undefined;
+                    level?: undefined;
+                    items?: undefined;
+                    callId?: undefined;
+                    name?: undefined;
+                    error?: undefined;
+                    detail?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    items: {
+                        type: string;
+                        items: {
+                            type: string;
+                            properties: {
+                                id: {
+                                    type: string;
+                                };
+                                text: {
+                                    type: string;
+                                };
+                                status: {
+                                    enum: string[];
+                                };
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        };
+                    };
+                    text?: undefined;
+                    clientMessageId?: undefined;
+                    level?: undefined;
+                    status?: undefined;
+                    trigger?: undefined;
+                    preTokens?: undefined;
+                    postTokens?: undefined;
+                    callId?: undefined;
+                    name?: undefined;
+                    error?: undefined;
+                    detail?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            } | {
+                type: string;
+                properties: {
+                    kind: {
+                        const: string;
+                    };
+                    id: {
+                        type: string;
+                    };
+                    callId: {
+                        type: string;
+                    };
+                    name: {
+                        type: string;
+                    };
+                    status: {
+                        enum: string[];
+                    };
+                    error: {
+                        type: string;
+                    };
+                    detail: {
+                        oneOf: ({
+                            type: string;
+                            properties: {
+                                type: {
+                                    const: string;
+                                };
+                                command: {
+                                    type: string;
+                                };
+                                cwd: {
+                                    type: string;
+                                };
+                                output: {
+                                    type: string;
+                                };
+                                exitCode: {
+                                    type: string[];
+                                };
+                                input?: undefined;
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        } | {
+                            type: string;
+                            properties: {
+                                type: {
+                                    const: string;
+                                };
+                                input: {};
+                                output: {
+                                    type?: undefined;
+                                };
+                                command?: undefined;
+                                cwd?: undefined;
+                                exitCode?: undefined;
+                            };
+                            required: string[];
+                            additionalProperties: boolean;
+                        })[];
+                    };
+                    text?: undefined;
+                    clientMessageId?: undefined;
+                    level?: undefined;
+                    trigger?: undefined;
+                    preTokens?: undefined;
+                    postTokens?: undefined;
+                    items?: undefined;
+                };
+                required: string[];
+                additionalProperties: boolean;
+            })[];
+            export { oneOf_2 as oneOf };
+        }
+        export namespace unknownItem {
+            let type_82: string;
+            export { type_82 as type };
+            export namespace properties_13 {
+                export namespace kind_2 {
+                    let type_83: string;
+                    export { type_83 as type };
+                    export namespace not_1 {
+                        let _enum_4: string[];
+                        export { _enum_4 as enum };
+                    }
+                    export { not_1 as not };
+                }
+                export { kind_2 as kind };
+                export namespace id_6 {
+                    let type_84: string;
+                    export { type_84 as type };
+                }
+                export { id_6 as id };
+            }
+            export { properties_13 as properties };
+            let required_13: string[];
+            export { required_13 as required };
+            let additionalProperties_13: boolean;
+            export { additionalProperties_13 as additionalProperties };
+        }
+        export namespace alpError {
+            let type_85: string;
+            export { type_85 as type };
+            export namespace properties_14 {
+                export namespace message_1 {
+                    let type_86: string;
+                    export { type_86 as type };
+                }
+                export { message_1 as message };
+                export namespace code_1 {
+                    let type_87: string;
+                    export { type_87 as type };
+                }
+                export { code_1 as code };
+            }
+            export { properties_14 as properties };
+            let required_14: string[];
+            export { required_14 as required };
+            let additionalProperties_14: boolean;
+            export { additionalProperties_14 as additionalProperties };
+        }
+        export namespace sessionSummary {
+            let type_88: string;
+            export { type_88 as type };
+            export namespace properties_15 {
+                export namespace id_7 {
+                    let type_89: string;
+                    export { type_89 as type };
+                }
+                export { id_7 as id };
+                export namespace projectRoot_1 {
+                    let type_90: string;
+                    export { type_90 as type };
+                }
+                export { projectRoot_1 as projectRoot };
+                export namespace agent_5 {
+                    let type_91: string;
+                    export { type_91 as type };
+                }
+                export { agent_5 as agent };
+                export namespace runtime_1 {
+                    let _enum_5: string[];
+                    export { _enum_5 as enum };
+                }
+                export { runtime_1 as runtime };
+                export namespace model_2 {
+                    let type_92: string;
+                    export { type_92 as type };
+                }
+                export { model_2 as model };
+                export namespace mode_4 {
+                    let type_93: string;
+                    export { type_93 as type };
+                }
+                export { mode_4 as mode };
+                export namespace thinking_2 {
+                    let type_94: string;
+                    export { type_94 as type };
+                }
+                export { thinking_2 as thinking };
+                export namespace workflow_1 {
+                    let type_95: string;
+                    export { type_95 as type };
+                    export namespace properties_16 {
+                        export namespace mode_5 {
+                            let type_96: string;
+                            export { type_96 as type };
+                        }
+                        export { mode_5 as mode };
+                        export namespace maxPeers_1 {
+                            let type_97: string;
+                            export { type_97 as type };
+                        }
+                        export { maxPeers_1 as maxPeers };
+                        export namespace supervisor_1 {
+                            let type_98: string;
+                            export { type_98 as type };
+                        }
+                        export { supervisor_1 as supervisor };
+                    }
+                    export { properties_16 as properties };
+                    let required_15: string[];
+                    export { required_15 as required };
+                    let additionalProperties_15: boolean;
+                    export { additionalProperties_15 as additionalProperties };
+                }
+                export { workflow_1 as workflow };
+                export namespace threadId_1 {
+                    let type_99: string;
+                    export { type_99 as type };
+                }
+                export { threadId_1 as threadId };
+                export namespace persistent_1 {
+                    let type_100: string;
+                    export { type_100 as type };
+                }
+                export { persistent_1 as persistent };
+                export namespace busy_1 {
+                    let type_101: string;
+                    export { type_101 as type };
+                }
+                export { busy_1 as busy };
+                export namespace parentId_1 {
+                    let type_102: string;
+                    export { type_102 as type };
+                }
+                export { parentId_1 as parentId };
+                export namespace toolCallId_1 {
+                    let type_103: string;
+                    export { type_103 as type };
+                }
+                export { toolCallId_1 as toolCallId };
+                export namespace activeTurnId_1 {
+                    let type_104: string;
+                    export { type_104 as type };
+                }
+                export { activeTurnId_1 as activeTurnId };
+                export namespace parked_1 {
+                    let type_105: string;
+                    export { type_105 as type };
+                }
+                export { parked_1 as parked };
+                export namespace instructionsSha_1 {
+                    let type_106: string;
+                    export { type_106 as type };
+                }
+                export { instructionsSha_1 as instructionsSha };
+                export namespace teamLabel_1 {
+                    let type_107: string;
+                    export { type_107 as type };
+                }
+                export { teamLabel_1 as teamLabel };
+                export namespace status_1 {
+                    let _enum_6: string[];
+                    export { _enum_6 as enum };
+                }
+                export { status_1 as status };
+                export namespace title {
+                    let type_108: string;
+                    export { type_108 as type };
+                }
+                export namespace archived {
+                    let type_109: string;
+                    export { type_109 as type };
+                }
+                export namespace lastError {
+                    let type_110: string;
+                    export { type_110 as type };
+                    export namespace properties_17 {
+                        export namespace code_2 {
+                            let type_111: string;
+                            export { type_111 as type };
+                        }
+                        export { code_2 as code };
+                        export namespace message_2 {
+                            let type_112: string;
+                            export { type_112 as type };
+                        }
+                        export { message_2 as message };
+                    }
+                    export { properties_17 as properties };
+                    let required_16: string[];
+                    export { required_16 as required };
+                    let additionalProperties_16: boolean;
+                    export { additionalProperties_16 as additionalProperties };
+                }
+                export namespace createdAt {
+                    let type_113: string;
+                    export { type_113 as type };
+                }
+                export namespace updatedAt {
+                    let type_114: string;
+                    export { type_114 as type };
+                }
+            }
+            export { properties_15 as properties };
+            let required_17: string[];
+            export { required_17 as required };
+            let additionalProperties_17: boolean;
+            export { additionalProperties_17 as additionalProperties };
+        }
+        export namespace pause {
+            let type_115: string;
+            export { type_115 as type };
+            export namespace properties_18 {
+                namespace since {
+                    let type_116: string;
+                    export { type_116 as type };
+                }
+                namespace by {
+                    let type_117: string;
+                    export { type_117 as type };
+                }
+                namespace reason {
+                    let type_118: string;
+                    export { type_118 as type };
+                }
+                namespace resetsAt {
+                    let type_119: string;
+                    export { type_119 as type };
+                }
+                namespace checkedAt {
+                    let type_120: string;
+                    export { type_120 as type };
+                }
+            }
+            export { properties_18 as properties };
+            let required_18: string[];
+            export { required_18 as required };
+            let additionalProperties_18: boolean;
+            export { additionalProperties_18 as additionalProperties };
+        }
+        export namespace pauseState {
+            let type_121: string;
+            export { type_121 as type };
+            export namespace properties_19 {
+                export namespace all {
+                    let $ref_2: string;
+                    export { $ref_2 as $ref };
+                }
+                export namespace runtimes {
+                    let type_122: string;
+                    export { type_122 as type };
+                    export namespace additionalProperties_19 {
+                        let $ref_3: string;
+                        export { $ref_3 as $ref };
+                    }
+                    export { additionalProperties_19 as additionalProperties };
+                }
+                export namespace parked_2 {
+                    let type_123: string;
+                    export { type_123 as type };
+                    export namespace items_2 {
+                        let type_124: string;
+                        export { type_124 as type };
+                        export namespace properties_20 {
+                            export namespace assignmentId {
+                                let type_125: string;
+                                export { type_125 as type };
+                            }
+                            export namespace agent_6 {
+                                let type_126: string;
+                                export { type_126 as type };
+                            }
+                            export { agent_6 as agent };
+                            export namespace runtime_2 {
+                                let type_127: string;
+                                export { type_127 as type };
+                            }
+                            export { runtime_2 as runtime };
+                            export namespace rootId_2 {
+                                let type_128: string;
+                                export { type_128 as type };
+                            }
+                            export { rootId_2 as rootId };
+                            export namespace reason_1 {
+                                let type_129: string;
+                                export { type_129 as type };
+                            }
+                            export { reason_1 as reason };
+                            export namespace since_1 {
+                                let type_130: string;
+                                export { type_130 as type };
+                            }
+                            export { since_1 as since };
+                        }
+                        export { properties_20 as properties };
+                        let required_19: string[];
+                        export { required_19 as required };
+                        let additionalProperties_20: boolean;
+                        export { additionalProperties_20 as additionalProperties };
+                    }
+                    export { items_2 as items };
+                }
+                export { parked_2 as parked };
+            }
+            export { properties_19 as properties };
+            let required_20: string[];
+            export { required_20 as required };
+            let additionalProperties_21: boolean;
+            export { additionalProperties_21 as additionalProperties };
+        }
+        export namespace preview {
+            let type_131: string;
+            export { type_131 as type };
+            export namespace properties_21 {
+                export namespace teams {
+                    let type_132: string;
+                    export { type_132 as type };
+                    export namespace items_3 {
+                        let type_133: string;
+                        export { type_133 as type };
+                        export namespace properties_22 {
+                            export namespace id_8 {
+                                let type_134: string;
+                                export { type_134 as type };
+                            }
+                            export { id_8 as id };
+                            export namespace label {
+                                let type_135: string;
+                                export { type_135 as type };
+                            }
+                            export namespace description {
+                                let type_136: string;
+                                export { type_136 as type };
+                            }
+                        }
+                        export { properties_22 as properties };
+                        let required_21: string[];
+                        export { required_21 as required };
+                        let additionalProperties_22: boolean;
+                        export { additionalProperties_22 as additionalProperties };
+                    }
+                    export { items_3 as items };
+                }
+                export namespace team {
+                    let type_137: string;
+                    export { type_137 as type };
+                }
+                export namespace teamLabel_2 {
+                    let type_138: string;
+                    export { type_138 as type };
+                }
+                export { teamLabel_2 as teamLabel };
+                export namespace agent_7 {
+                    let type_139: string;
+                    export { type_139 as type };
+                }
+                export { agent_7 as agent };
+                export namespace runtime_3 {
+                    let _enum_7: string[];
+                    export { _enum_7 as enum };
+                }
+                export { runtime_3 as runtime };
+                export namespace model_3 {
+                    let type_140: string;
+                    export { type_140 as type };
+                }
+                export { model_3 as model };
+                export namespace mode_6 {
+                    let type_141: string;
+                    export { type_141 as type };
+                }
+                export { mode_6 as mode };
+                export namespace thinking_3 {
+                    let type_142: string;
+                    export { type_142 as type };
+                }
+                export { thinking_3 as thinking };
+            }
+            export { properties_21 as properties };
+            let required_22: string[];
+            export { required_22 as required };
+            let additionalProperties_23: boolean;
+            export { additionalProperties_23 as additionalProperties };
+        }
+        export namespace treeStatus {
+            let type_143: string;
+            export { type_143 as type };
+            export namespace properties_23 {
+                export namespace rootId_3 {
+                    let type_144: string;
+                    export { type_144 as type };
+                }
+                export { rootId_3 as rootId };
+                export namespace sessions {
+                    let type_145: string;
+                    export { type_145 as type };
+                    export namespace items_4 {
+                        let type_146: string;
+                        export { type_146 as type };
+                        export namespace properties_24 {
+                            export namespace id_9 {
+                                let type_147: string;
+                                export { type_147 as type };
+                            }
+                            export { id_9 as id };
+                            export namespace projectRoot_2 {
+                                let type_148: string;
+                                export { type_148 as type };
+                            }
+                            export { projectRoot_2 as projectRoot };
+                            export namespace agent_8 {
+                                let type_149: string;
+                                export { type_149 as type };
+                            }
+                            export { agent_8 as agent };
+                            export namespace runtime_4 {
+                                let _enum_8: string[];
+                                export { _enum_8 as enum };
+                            }
+                            export { runtime_4 as runtime };
+                            export namespace model_4 {
+                                let type_150: string;
+                                export { type_150 as type };
+                            }
+                            export { model_4 as model };
+                            export namespace mode_7 {
+                                let type_151: string;
+                                export { type_151 as type };
+                            }
+                            export { mode_7 as mode };
+                            export namespace thinking_4 {
+                                let type_152: string;
+                                export { type_152 as type };
+                            }
+                            export { thinking_4 as thinking };
+                            export namespace workflow_2 {
+                                let type_153: string;
+                                export { type_153 as type };
+                                export namespace properties_25 {
+                                    export namespace mode_8 {
+                                        let type_154: string;
+                                        export { type_154 as type };
+                                    }
+                                    export { mode_8 as mode };
+                                    export namespace maxPeers_2 {
+                                        let type_155: string;
+                                        export { type_155 as type };
+                                    }
+                                    export { maxPeers_2 as maxPeers };
+                                    export namespace supervisor_2 {
+                                        let type_156: string;
+                                        export { type_156 as type };
+                                    }
+                                    export { supervisor_2 as supervisor };
+                                }
+                                export { properties_25 as properties };
+                                let required_23: string[];
+                                export { required_23 as required };
+                                let additionalProperties_24: boolean;
+                                export { additionalProperties_24 as additionalProperties };
+                            }
+                            export { workflow_2 as workflow };
+                            export namespace threadId_2 {
+                                let type_157: string;
+                                export { type_157 as type };
+                            }
+                            export { threadId_2 as threadId };
+                            export namespace persistent_2 {
+                                let type_158: string;
+                                export { type_158 as type };
+                            }
+                            export { persistent_2 as persistent };
+                            export namespace busy_2 {
+                                let type_159: string;
+                                export { type_159 as type };
+                            }
+                            export { busy_2 as busy };
+                            export namespace parentId_2 {
+                                let type_160: string;
+                                export { type_160 as type };
+                            }
+                            export { parentId_2 as parentId };
+                            export namespace toolCallId_2 {
+                                let type_161: string;
+                                export { type_161 as type };
+                            }
+                            export { toolCallId_2 as toolCallId };
+                            export namespace activeTurnId_2 {
+                                let type_162: string;
+                                export { type_162 as type };
+                            }
+                            export { activeTurnId_2 as activeTurnId };
+                            export namespace parked_3 {
+                                let type_163: string;
+                                export { type_163 as type };
+                            }
+                            export { parked_3 as parked };
+                            export namespace instructionsSha_2 {
+                                let type_164: string;
+                                export { type_164 as type };
+                            }
+                            export { instructionsSha_2 as instructionsSha };
+                            export namespace teamLabel_3 {
+                                let type_165: string;
+                                export { type_165 as type };
+                            }
+                            export { teamLabel_3 as teamLabel };
+                            export namespace state {
+                                let _enum_9: string[];
+                                export { _enum_9 as enum };
+                            }
+                            export namespace idleMs {
+                                let type_166: string;
+                                export { type_166 as type };
+                            }
+                            export namespace workdir {
+                                let type_167: string;
+                                export { type_167 as type };
+                            }
+                            export namespace unreadMail {
+                                let type_168: string;
+                                export { type_168 as type };
+                                let minimum_2: number;
+                                export { minimum_2 as minimum };
+                            }
+                        }
+                        export { properties_24 as properties };
+                        let required_24: string[];
+                        export { required_24 as required };
+                        let additionalProperties_25: boolean;
+                        export { additionalProperties_25 as additionalProperties };
+                    }
+                    export { items_4 as items };
+                }
+                export namespace assignments {
+                    let type_169: string;
+                    export { type_169 as type };
+                    export namespace items_5 {
+                        let type_170: string;
+                        export { type_170 as type };
+                        export namespace properties_26 {
+                            export namespace id_10 {
+                                let type_171: string;
+                                export { type_171 as type };
+                            }
+                            export { id_10 as id };
+                            export namespace requester {
+                                let type_172: string;
+                                export { type_172 as type };
+                            }
+                            export namespace isolation {
+                                let _enum_10: string[];
+                                export { _enum_10 as enum };
+                            }
+                            export namespace idleMs_1 {
+                                let type_173: string;
+                                export { type_173 as type };
+                            }
+                            export { idleMs_1 as idleMs };
+                        }
+                        export { properties_26 as properties };
+                        let required_25: string[];
+                        export { required_25 as required };
+                        let additionalProperties_26: boolean;
+                        export { additionalProperties_26 as additionalProperties };
+                    }
+                    export { items_5 as items };
+                }
+                export namespace questions {
+                    let type_174: string;
+                    export { type_174 as type };
+                    export namespace items_6 {
+                        let $ref_4: string;
+                        export { $ref_4 as $ref };
+                    }
+                    export { items_6 as items };
+                }
+                export namespace worktrees {
+                    let type_175: string;
+                    export { type_175 as type };
+                    export namespace items_7 {
+                        let type_176: string;
+                        export { type_176 as type };
+                        export namespace properties_27 {
+                            export namespace assignmentId_1 {
+                                let type_177: string;
+                                export { type_177 as type };
+                            }
+                            export { assignmentId_1 as assignmentId };
+                            export namespace requester_1 {
+                                let type_178: string;
+                                export { type_178 as type };
+                            }
+                            export { requester_1 as requester };
+                            export namespace agent_9 {
+                                let type_179: string;
+                                export { type_179 as type };
+                            }
+                            export { agent_9 as agent };
+                            export namespace branch_1 {
+                                let type_180: string;
+                                export { type_180 as type };
+                            }
+                            export { branch_1 as branch };
+                            export namespace files {
+                                let type_181: string;
+                                export { type_181 as type };
+                                export namespace items_8 {
+                                    let type_182: string;
+                                    export { type_182 as type };
+                                }
+                                export { items_8 as items };
+                            }
+                            export namespace stat {
+                                let type_183: string;
+                                export { type_183 as type };
+                            }
+                        }
+                        export { properties_27 as properties };
+                        let required_26: string[];
+                        export { required_26 as required };
+                        let additionalProperties_27: boolean;
+                        export { additionalProperties_27 as additionalProperties };
+                    }
+                    export { items_7 as items };
+                }
+                export namespace leases {
+                    let type_184: string;
+                    export { type_184 as type };
+                    export namespace items_9 {
+                        let type_185: string;
+                        export { type_185 as type };
+                        export namespace properties_28 {
+                            export namespace checkout {
+                                let type_186: string;
+                                export { type_186 as type };
+                            }
+                            export namespace assignmentId_2 {
+                                let type_187: string;
+                                export { type_187 as type };
+                            }
+                            export { assignmentId_2 as assignmentId };
+                            export namespace agent_10 {
+                                let type_188: string;
+                                export { type_188 as type };
+                            }
+                            export { agent_10 as agent };
+                        }
+                        export { properties_28 as properties };
+                        let required_27: string[];
+                        export { required_27 as required };
+                        let additionalProperties_28: boolean;
+                        export { additionalProperties_28 as additionalProperties };
+                    }
+                    export { items_9 as items };
+                }
+                export namespace claims {
+                    let type_189: string;
+                    export { type_189 as type };
+                    export namespace items_10 {
+                        let $ref_5: string;
+                        export { $ref_5 as $ref };
+                    }
+                    export { items_10 as items };
+                }
+            }
+            export { properties_23 as properties };
+            let required_28: string[];
+            export { required_28 as required };
+            let additionalProperties_29: boolean;
+            export { additionalProperties_29 as additionalProperties };
+        }
+        export namespace health {
+            let type_190: string;
+            export { type_190 as type };
+            export namespace properties_29 {
+                namespace live {
+                    let type_191: string;
+                    export { type_191 as type };
+                }
+                namespace ready {
+                    let type_192: string;
+                    export { type_192 as type };
+                }
+                namespace checks {
+                    let type_193: string;
+                    export { type_193 as type };
+                    export namespace items_11 {
+                        let type_194: string;
+                        export { type_194 as type };
+                        export namespace properties_30 {
+                            export namespace id_11 {
+                                let type_195: string;
+                                export { type_195 as type };
+                            }
+                            export { id_11 as id };
+                            export namespace ok {
+                                let type_196: string;
+                                export { type_196 as type };
+                            }
+                            export namespace code_3 {
+                                let type_197: string;
+                                export { type_197 as type };
+                            }
+                            export { code_3 as code };
+                            export namespace message_3 {
+                                let type_198: string;
+                                export { type_198 as type };
+                            }
+                            export { message_3 as message };
+                        }
+                        export { properties_30 as properties };
+                        let required_29: string[];
+                        export { required_29 as required };
+                        let additionalProperties_30: boolean;
+                        export { additionalProperties_30 as additionalProperties };
+                    }
+                    export { items_11 as items };
+                }
+            }
+            export { properties_29 as properties };
+            let required_30: string[];
+            export { required_30 as required };
+            let additionalProperties_31: boolean;
+            export { additionalProperties_31 as additionalProperties };
+        }
+        export namespace projectRoot_3 {
+            let type_199: string;
+            export { type_199 as type };
+            export let minLength: number;
+            export let maxLength: number;
+            let description_1: string;
+            export { description_1 as description };
+        }
+        export { projectRoot_3 as projectRoot };
+        export namespace taskId {
+            let type_200: string;
+            export { type_200 as type };
+            export let pattern: string;
+        }
+        export namespace taskRow {
+            let type_201: string;
+            export { type_201 as type };
+            export namespace properties_31 {
+                export namespace id_12 {
+                    let $ref_6: string;
+                    export { $ref_6 as $ref };
+                }
+                export { id_12 as id };
+                export namespace title_1 {
+                    let type_202: string;
+                    export { type_202 as type };
+                }
+                export { title_1 as title };
+                export namespace type_203 {
+                    let type_204: string;
+                    export { type_204 as type };
+                }
+                export { type_203 as type };
+                export namespace priority {
+                    let type_205: string;
+                    export { type_205 as type };
+                }
+                export namespace status_2 {
+                    let _enum_11: string[];
+                    export { _enum_11 as enum };
+                }
+                export { status_2 as status };
+                export namespace rev {
+                    let type_206: string;
+                    export { type_206 as type };
+                    let minimum_3: number;
+                    export { minimum_3 as minimum };
+                }
+                export namespace parent {
+                    let type_207: string;
+                    export { type_207 as type };
+                }
+                export namespace assignee {
+                    let type_208: string;
+                    export { type_208 as type };
+                }
+                export namespace ready_1 {
+                    let type_209: string;
+                    export { type_209 as type };
+                }
+                export { ready_1 as ready };
+                export namespace blockedBy {
+                    let type_210: string;
+                    export { type_210 as type };
+                    export namespace items_12 {
+                        let type_211: string;
+                        export { type_211 as type };
+                    }
+                    export { items_12 as items };
+                }
+                export namespace waits {
+                    let type_212: string;
+                    export { type_212 as type };
+                    export namespace items_13 {
+                        let type_213: string;
+                        export { type_213 as type };
+                    }
+                    export { items_13 as items };
+                }
+                export namespace approvals {
+                    let type_214: string;
+                    export { type_214 as type };
+                    export namespace items_14 {
+                        let type_215: string;
+                        export { type_215 as type };
+                        export namespace properties_32 {
+                            namespace gate {
+                                let type_216: string;
+                                export { type_216 as type };
+                            }
+                            namespace note {
+                                let type_217: string;
+                                export { type_217 as type };
+                            }
+                        }
+                        export { properties_32 as properties };
+                        let required_31: string[];
+                        export { required_31 as required };
+                        let additionalProperties_32: boolean;
+                        export { additionalProperties_32 as additionalProperties };
+                    }
+                    export { items_14 as items };
+                }
+                export namespace handoff {
+                    let type_218: string;
+                    export { type_218 as type };
+                    export namespace properties_33 {
+                        export namespace outcome {
+                            let type_219: string;
+                            export { type_219 as type };
+                        }
+                        export namespace summary {
+                            let type_220: string;
+                            export { type_220 as type };
+                        }
+                        export namespace agent_11 {
+                            let type_221: string;
+                            export { type_221 as type };
+                        }
+                        export { agent_11 as agent };
+                    }
+                    export { properties_33 as properties };
+                    let required_32: string[];
+                    export { required_32 as required };
+                    let additionalProperties_33: boolean;
+                    export { additionalProperties_33 as additionalProperties };
+                }
+                export namespace closed {
+                    let type_222: string;
+                    export { type_222 as type };
+                    export namespace properties_34 {
+                        export namespace reason_2 {
+                            let type_223: string;
+                            export { type_223 as type };
+                        }
+                        export { reason_2 as reason };
+                        export namespace summary_1 {
+                            let type_224: string;
+                            export { type_224 as type };
+                        }
+                        export { summary_1 as summary };
+                        export namespace at_1 {
+                            let type_225: string;
+                            export { type_225 as type };
+                        }
+                        export { at_1 as at };
+                    }
+                    export { properties_34 as properties };
+                    let required_33: string[];
+                    export { required_33 as required };
+                    let additionalProperties_34: boolean;
+                    export { additionalProperties_34 as additionalProperties };
+                }
+                export namespace description_2 {
+                    let type_226: string;
+                    export { type_226 as type };
+                }
+                export { description_2 as description };
+                export namespace labels {
+                    let type_227: string;
+                    export { type_227 as type };
+                    export namespace items_15 {
+                        let type_228: string;
+                        export { type_228 as type };
+                    }
+                    export { items_15 as items };
+                }
+                export namespace paths_1 {
+                    let type_229: string;
+                    export { type_229 as type };
+                    export namespace items_16 {
+                        let type_230: string;
+                        export { type_230 as type };
+                    }
+                    export { items_16 as items };
+                }
+                export { paths_1 as paths };
+                export namespace progress {
+                    let type_231: string;
+                    export { type_231 as type };
+                    export namespace properties_35 {
+                        namespace done {
+                            let type_232: string;
+                            export { type_232 as type };
+                            let minimum_4: number;
+                            export { minimum_4 as minimum };
+                        }
+                        namespace total {
+                            let type_233: string;
+                            export { type_233 as type };
+                            let minimum_5: number;
+                            export { minimum_5 as minimum };
+                        }
+                    }
+                    export { properties_35 as properties };
+                    let required_34: string[];
+                    export { required_34 as required };
+                    let additionalProperties_35: boolean;
+                    export { additionalProperties_35 as additionalProperties };
+                }
+                export namespace createdAt_1 {
+                    let type_234: string;
+                    export { type_234 as type };
+                }
+                export { createdAt_1 as createdAt };
+                export namespace updatedAt_1 {
+                    let type_235: string;
+                    export { type_235 as type };
+                }
+                export { updatedAt_1 as updatedAt };
+            }
+            export { properties_31 as properties };
+            let required_35: string[];
+            export { required_35 as required };
+            let additionalProperties_36: boolean;
+            export { additionalProperties_36 as additionalProperties };
+        }
+        export namespace libraryKind {
+            let _enum_12: string[];
+            export { _enum_12 as enum };
+        }
+        export namespace libraryScope {
+            let _enum_13: string[];
+            export { _enum_13 as enum };
+        }
+        export namespace librarySource {
+            let _enum_14: string[];
+            export { _enum_14 as enum };
+        }
+        export namespace entryName {
+            let type_236: string;
+            export { type_236 as type };
+            let minLength_1: number;
+            export { minLength_1 as minLength };
+            let maxLength_1: number;
+            export { maxLength_1 as maxLength };
+            let pattern_1: string;
+            export { pattern_1 as pattern };
+            export namespace not_2 {
+                let _enum_15: string[];
+                export { _enum_15 as enum };
+            }
+            export { not_2 as not };
+        }
+        export namespace libraryRevision {
+            let type_237: string[];
+            export { type_237 as type };
+        }
+        export namespace libraryEntryRow {
+            let type_238: string;
+            export { type_238 as type };
+            export namespace properties_36 {
+                export namespace name {
+                    let type_239: string;
+                    export { type_239 as type };
+                }
+                export namespace source {
+                    let $ref_7: string;
+                    export { $ref_7 as $ref };
+                }
+                export namespace overrides {
+                    let $ref_8: string;
+                    export { $ref_8 as $ref };
+                }
+                export namespace description_3 {
+                    let type_240: string;
+                    export { type_240 as type };
+                }
+                export { description_3 as description };
+                export namespace usedBy {
+                    let type_241: string;
+                    export { type_241 as type };
+                    export namespace items_17 {
+                        let type_242: string;
+                        export { type_242 as type };
+                    }
+                    export { items_17 as items };
+                }
+            }
+            export { properties_36 as properties };
+            let required_36: string[];
+            export { required_36 as required };
+            let additionalProperties_37: boolean;
+            export { additionalProperties_37 as additionalProperties };
+        }
+        export namespace secretMarker {
+            let type_243: string;
+            export { type_243 as type };
+            export namespace properties_37 {
+                namespace $secret {
+                    let _const_3: string;
+                    export { _const_3 as const };
+                }
+            }
+            export { properties_37 as properties };
+            let required_37: string[];
+            export { required_37 as required };
+            let additionalProperties_38: boolean;
+            export { additionalProperties_38 as additionalProperties };
+            let description_4: string;
+            export { description_4 as description };
+        }
+        export namespace languageSetting {
+            let type_244: string;
+            export { type_244 as type };
+            export namespace properties_38 {
+                export namespace language {
+                    let type_245: string[];
+                    export { type_245 as type };
+                }
+                export namespace applies {
+                    let type_246: string;
+                    export { type_246 as type };
+                }
+                namespace _default {
+                    let type_247: string;
+                    export { type_247 as type };
+                }
+                export { _default as default };
+            }
+            export { properties_38 as properties };
+            let required_38: string[];
+            export { required_38 as required };
+            let additionalProperties_39: boolean;
+            export { additionalProperties_39 as additionalProperties };
+        }
+        export namespace teamRow {
+            let type_248: string;
+            export { type_248 as type };
+            export namespace properties_39 {
+                export namespace id_13 {
+                    let type_249: string;
+                    export { type_249 as type };
+                }
+                export { id_13 as id };
+                export namespace label_1 {
+                    let type_250: string;
+                    export { type_250 as type };
+                }
+                export { label_1 as label };
+                export namespace description_5 {
+                    let type_251: string;
+                    export { type_251 as type };
+                }
+                export { description_5 as description };
+                export namespace source_1 {
+                    let $ref_9: string;
+                    export { $ref_9 as $ref };
+                }
+                export { source_1 as source };
+                export namespace overrides_1 {
+                    let $ref_10: string;
+                    export { $ref_10 as $ref };
+                }
+                export { overrides_1 as overrides };
+                export namespace error_1 {
+                    let type_252: string;
+                    export { type_252 as type };
+                }
+                export { error_1 as error };
+            }
+            export { properties_39 as properties };
+            let required_39: string[];
+            export { required_39 as required };
+            let additionalProperties_40: boolean;
+            export { additionalProperties_40 as additionalProperties };
+        }
+    }
+}