@vibesdotdev/forge 0.0.0-stage → 1.0.0-rc.5

package/dist/schemas/wire-contracts.d.ts

@@ -0,0 +1,2474 @@
+import { type TrackingItemStatus } from '../tracking/index.ts';
+import { TrackingCommentSourceSchema, TrackingReviewSideSchema, TrackingReviewStateSchema, StatusCheckStateSchema, StatusCheckResultSchema, StatusCheckSchema, StatusCheckArraySchema, type StatusCheckResult, type StatusCheckState, type StatusCheck } from '@vibesdotdev/tracking-schemas';
+import * as z from 'zod/v4';
+export { TrackingPrCiStatusSchema, TrackingPrStateSchema } from '../tracking/index.ts';
+/**
+ * Comment/review enums and the status-check wire shape now live in the
+ * `tracking-schemas` leaf (App's tracking-item metadata bag embeds the same
+ * shape); re-exported here under their original names for back-compat. The
+ * merge-policy HELPERS below (`aggregateStatusChecks` and friends) stay
+ * forge-owned — only the transport-neutral shape moved.
+ */
+export { TrackingCommentSourceSchema, TrackingReviewSideSchema, TrackingReviewStateSchema, StatusCheckStateSchema, StatusCheckResultSchema, StatusCheckSchema, StatusCheckArraySchema };
+export type { StatusCheckResult, StatusCheckState, StatusCheck };
+/** Repository ref accepted by every repository-scoped Forge request. */
+export declare const RepoRefSchema: z.ZodString;
+export declare const ListReposInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+    provider: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    ownerType: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        organization: "organization";
+    }>>;
+    ownerId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RepositorySummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    ownerType: z.ZodOptional<z.ZodString>;
+    ownerId: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    visibility: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    statusMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    defaultBranch: z.ZodOptional<z.ZodString>;
+    externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cloneUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    webUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type RepositorySummary = z.infer<typeof RepositorySummarySchema>;
+export declare const CloneCredentialSchema: z.ZodObject<{
+    username: z.ZodOptional<z.ZodString>;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type CloneCredential = z.infer<typeof CloneCredentialSchema>;
+export declare const ListReposOutputSchema: z.ZodObject<{
+    repositories: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        ownerType: z.ZodOptional<z.ZodString>;
+        ownerId: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        visibility: z.ZodOptional<z.ZodString>;
+        status: z.ZodOptional<z.ZodString>;
+        statusMessage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        defaultBranch: z.ZodOptional<z.ZodString>;
+        externalId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        cloneUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        webUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+    notices: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** Public response shape for a PR nested in a tracking item. */
+export declare const TrackingPrResultSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    targetRef: z.ZodString;
+    mergeBase: z.ZodOptional<z.ZodString>;
+    headSha: z.ZodOptional<z.ZodString>;
+    mergeCommitSha: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        open: "open";
+        draft: "draft";
+        merged: "merged";
+        closed: "closed";
+    }>;
+    ciStatus: z.ZodOptional<z.ZodEnum<{
+        success: "success";
+        error: "error";
+        pending: "pending";
+        failure: "failure";
+    }>>;
+    stack: z.ZodOptional<z.ZodObject<{
+        id: z.ZodUUID;
+        stackNumber: z.ZodNumber;
+        position: z.ZodNumber;
+        size: z.ZodNumber;
+        trunkRef: z.ZodString;
+        state: z.ZodEnum<{
+            active: "active";
+            merged: "merged";
+            merging: "merging";
+            dissolved: "dissolved";
+        }>;
+        health: z.ZodEnum<{
+            clean: "clean";
+            "restack-required": "restack-required";
+            conflicted: "conflicted";
+        }>;
+        landingPolicy: z.ZodEnum<{
+            "batch-allowed": "batch-allowed";
+            "one-layer-at-a-time": "one-layer-at-a-time";
+        }>;
+        revision: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+/** Public response shape for an issue or pull-request tracking item. */
+export declare const TrackingItemResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    repositoryId: z.ZodOptional<z.ZodString>;
+    issueNumber: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodEnum<{
+        task: "task";
+        bug: "bug";
+        research: "research";
+        ops: "ops";
+        doc: "doc";
+        pr: "pr";
+    }>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        urgent: "urgent";
+    }>>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    ownerParticipantId: z.ZodOptional<z.ZodString>;
+    assignedParticipantId: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    pr: z.ZodOptional<z.ZodObject<{
+        sourceRef: z.ZodString;
+        targetRef: z.ZodString;
+        mergeBase: z.ZodOptional<z.ZodString>;
+        headSha: z.ZodOptional<z.ZodString>;
+        mergeCommitSha: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            open: "open";
+            draft: "draft";
+            merged: "merged";
+            closed: "closed";
+        }>;
+        ciStatus: z.ZodOptional<z.ZodEnum<{
+            success: "success";
+            error: "error";
+            pending: "pending";
+            failure: "failure";
+        }>>;
+        stack: z.ZodOptional<z.ZodObject<{
+            id: z.ZodUUID;
+            stackNumber: z.ZodNumber;
+            position: z.ZodNumber;
+            size: z.ZodNumber;
+            trunkRef: z.ZodString;
+            state: z.ZodEnum<{
+                active: "active";
+                merged: "merged";
+                merging: "merging";
+                dissolved: "dissolved";
+            }>;
+            health: z.ZodEnum<{
+                clean: "clean";
+                "restack-required": "restack-required";
+                conflicted: "conflicted";
+            }>;
+            landingPolicy: z.ZodEnum<{
+                "batch-allowed": "batch-allowed";
+                "one-layer-at-a-time": "one-layer-at-a-time";
+            }>;
+            revision: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$loose>>;
+    metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** Public response shape for an issue or PR comment. */
+export declare const TrackingCommentResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    itemId: z.ZodOptional<z.ZodString>;
+    authorParticipantId: z.ZodOptional<z.ZodString>;
+    body: z.ZodString;
+    source: z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+        system: "system";
+    }>;
+    sourceSessionId: z.ZodOptional<z.ZodString>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+    reviewPath: z.ZodOptional<z.ZodString>;
+    reviewLine: z.ZodOptional<z.ZodNumber>;
+    reviewSide: z.ZodOptional<z.ZodEnum<{
+        old: "old";
+        new: "new";
+    }>>;
+    reviewCommitSha: z.ZodOptional<z.ZodString>;
+    reviewState: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+        commented: "commented";
+    }>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const IssueCreateInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        task: "task";
+        bug: "bug";
+        research: "research";
+        ops: "ops";
+        doc: "doc";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        urgent: "urgent";
+    }>>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assignedParticipantId: z.ZodOptional<z.ZodString>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const IssueCreateOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueListInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    type: z.ZodOptional<z.ZodEnum<{
+        task: "task";
+        bug: "bug";
+        research: "research";
+        ops: "ops";
+        doc: "doc";
+    }>>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const IssueListOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const IssueGetInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, z.core.$strip>;
+export declare const IssueGetOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueUpdateInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    type: z.ZodOptional<z.ZodEnum<{
+        task: "task";
+        bug: "bug";
+        research: "research";
+        ops: "ops";
+        doc: "doc";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        urgent: "urgent";
+    }>>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assignedParticipantId: z.ZodOptional<z.ZodString>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const IssueUpdateOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueCloseInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    status: z.ZodDefault<z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+}, z.core.$strip>;
+export declare const IssueCloseOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueReopenInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    status: z.ZodDefault<z.ZodEnum<{
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+    }>>;
+}, z.core.$strip>;
+export declare const IssueReopenOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueCommentInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    body: z.ZodString;
+}, z.core.$strip>;
+/** Full platform comment-create contract, including review metadata. */
+export declare const ForgeIssueCommentCreateInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    body: z.ZodString;
+    source: z.ZodOptional<z.ZodEnum<{
+        human: "human";
+        agent: "agent";
+        system: "system";
+    }>>;
+    sourceSessionId: z.ZodOptional<z.ZodString>;
+    ephemeral: z.ZodOptional<z.ZodBoolean>;
+    reviewPath: z.ZodOptional<z.ZodString>;
+    reviewLine: z.ZodOptional<z.ZodNumber>;
+    reviewSide: z.ZodOptional<z.ZodEnum<{
+        old: "old";
+        new: "new";
+    }>>;
+    reviewCommitSha: z.ZodOptional<z.ZodString>;
+    reviewState: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+        commented: "commented";
+    }>>;
+}, z.core.$strip>;
+export declare const IssueCommentOutputSchema: z.ZodObject<{
+    comment: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        authorParticipantId: z.ZodOptional<z.ZodString>;
+        body: z.ZodString;
+        source: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+            system: "system";
+        }>;
+        sourceSessionId: z.ZodOptional<z.ZodString>;
+        ephemeral: z.ZodOptional<z.ZodBoolean>;
+        reviewPath: z.ZodOptional<z.ZodString>;
+        reviewLine: z.ZodOptional<z.ZodNumber>;
+        reviewSide: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        reviewCommitSha: z.ZodOptional<z.ZodString>;
+        reviewState: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+            commented: "commented";
+        }>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const IssueCommentsListInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, z.core.$strip>;
+export declare const IssueCommentsListOutputSchema: z.ZodObject<{
+    comments: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        authorParticipantId: z.ZodOptional<z.ZodString>;
+        body: z.ZodString;
+        source: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+            system: "system";
+        }>;
+        sourceSessionId: z.ZodOptional<z.ZodString>;
+        ephemeral: z.ZodOptional<z.ZodBoolean>;
+        reviewPath: z.ZodOptional<z.ZodString>;
+        reviewLine: z.ZodOptional<z.ZodNumber>;
+        reviewSide: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        reviewCommitSha: z.ZodOptional<z.ZodString>;
+        reviewState: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+            commented: "commented";
+        }>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const IssueSearchInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    q: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const IssueSearchOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const PullRequestCreateBodySchema: z.ZodObject<{
+    type: z.ZodLiteral<"pr">;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    pr: z.ZodObject<{
+        sourceRef: z.ZodString;
+        targetRef: z.ZodString;
+        headSha: z.ZodOptional<z.ZodString>;
+        state: z.ZodLiteral<"open">;
+    }, z.core.$strip>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type PullRequestCreateBody = z.infer<typeof PullRequestCreateBodySchema>;
+export declare const PrCreateInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    sourceRef: z.ZodString;
+    targetRef: z.ZodString;
+    headSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrCreateOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrListInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>>;
+    state: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        draft: "draft";
+        merged: "merged";
+        closed: "closed";
+    }>>;
+    authorParticipantId: z.ZodOptional<z.ZodString>;
+    assignedParticipantId: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const PrListOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const PrGetInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PrGetOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrUpdateInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        done: "done";
+        blocked: "blocked";
+        draft: "draft";
+        backlog: "backlog";
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+        cancelled: "cancelled";
+    }>>;
+    effortId: z.ZodOptional<z.ZodUUID>;
+    milestoneId: z.ZodOptional<z.ZodUUID>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    targetRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrUpdateOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrCloseInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    status: z.ZodDefault<z.ZodEnum<{
+        done: "done";
+        cancelled: "cancelled";
+    }>>;
+}, z.core.$strip>;
+export declare const PrCloseOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrReopenInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    status: z.ZodDefault<z.ZodEnum<{
+        planned: "planned";
+        in_progress: "in_progress";
+        in_review: "in_review";
+    }>>;
+}, z.core.$strip>;
+export declare const PrReopenOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrSearchInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    q: z.ZodString;
+    state: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        draft: "draft";
+        merged: "merged";
+        closed: "closed";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const PrSearchOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export declare const ForgeAuthorityGrantRequestSchema: z.ZodObject<{
+    expectedHeadSha: z.ZodString;
+    scope: z.ZodDefault<z.ZodLiteral<"protected-paths">>;
+}, z.core.$strip>;
+export declare const ForgeAuthorityGrantSchema: z.ZodObject<{
+    id: z.ZodString;
+    repositoryId: z.ZodString;
+    prNumber: z.ZodNumber;
+    headSha: z.ZodString;
+    scope: z.ZodString;
+    grantee: z.ZodObject<{
+        accountId: z.ZodString;
+        principalId: z.ZodString;
+        principalType: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+        }>;
+    }, z.core.$strict>;
+    notes: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ForgeAuthorityGrant = z.infer<typeof ForgeAuthorityGrantSchema>;
+export type HumanAuthorityGrant = ForgeAuthorityGrant;
+export declare const PrMergeStatusInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PrMergeStatusOutputSchema: z.ZodObject<{
+    protectedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    authorityRequired: z.ZodOptional<z.ZodBoolean>;
+    authoritySatisfied: z.ZodOptional<z.ZodBoolean>;
+    authorityBlockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    humanAuthorityGrant: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        repositoryId: z.ZodString;
+        prNumber: z.ZodNumber;
+        headSha: z.ZodString;
+        scope: z.ZodString;
+        grantee: z.ZodObject<{
+            accountId: z.ZodString;
+            principalId: z.ZodString;
+            principalType: z.ZodEnum<{
+                human: "human";
+                agent: "agent";
+            }>;
+        }, z.core.$strict>;
+        notes: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
+    mergeable: z.ZodBoolean;
+    ahead: z.ZodNullable<z.ZodNumber>;
+    behind: z.ZodNullable<z.ZodNumber>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    mergeBase: z.ZodOptional<z.ZodString>;
+    unavailable: z.ZodOptional<z.ZodString>;
+    statusChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        context: z.ZodString;
+        state: z.ZodEnum<{
+            success: "success";
+            error: "error";
+            pending: "pending";
+            failure: "failure";
+        }>;
+        sha: z.ZodString;
+        targetUrl: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        ciRunId: z.ZodOptional<z.ZodString>;
+        ciAttemptId: z.ZodOptional<z.ZodString>;
+        logsRef: z.ZodOptional<z.ZodString>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        updatedAt: z.ZodString;
+    }, z.core.$loose>>>;
+    checksBlockMerge: z.ZodOptional<z.ZodBoolean>;
+    reviewsBlockMerge: z.ZodOptional<z.ZodBoolean>;
+    currentHeadSha: z.ZodOptional<z.ZodString>;
+    requiredApprovals: z.ZodOptional<z.ZodNumber>;
+    approvalCount: z.ZodOptional<z.ZodNumber>;
+    branchPolicyBlockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    missingRequiredStatusChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    failingRequiredStatusChecks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const PrDiffHunkSchema: z.ZodObject<{
+    header: z.ZodOptional<z.ZodString>;
+    oldStart: z.ZodNumber;
+    oldLines: z.ZodNumber;
+    newStart: z.ZodNumber;
+    newLines: z.ZodNumber;
+    lines: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            context: "context";
+            add: "add";
+            del: "del";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PrDiffHunk = z.infer<typeof PrDiffHunkSchema>;
+/** One row of a PR files-changed list (hunks optional for size). */
+export declare const PrChangedFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        deleted: "deleted";
+        added: "added";
+        modified: "modified";
+        renamed: "renamed";
+    }>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    binary: z.ZodBoolean;
+    hunks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        header: z.ZodOptional<z.ZodString>;
+        oldStart: z.ZodNumber;
+        oldLines: z.ZodNumber;
+        newStart: z.ZodNumber;
+        newLines: z.ZodNumber;
+        lines: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                context: "context";
+                add: "add";
+                del: "del";
+            }>;
+            content: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const PrFilesInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    hunks: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const PrFilesOutputSchema: z.ZodObject<{
+    sourceRef: z.ZodString;
+    targetRef: z.ZodString;
+    headSha: z.ZodNullable<z.ZodString>;
+    fileCount: z.ZodNumber;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        oldPath: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            deleted: "deleted";
+            added: "added";
+            modified: "modified";
+            renamed: "renamed";
+        }>;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+        binary: z.ZodBoolean;
+        hunks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            header: z.ZodOptional<z.ZodString>;
+            oldStart: z.ZodNumber;
+            oldLines: z.ZodNumber;
+            newStart: z.ZodNumber;
+            newLines: z.ZodNumber;
+            lines: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    context: "context";
+                    add: "add";
+                    del: "del";
+                }>;
+                content: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    unavailable: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrMergeInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    expectedHeadSha: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        merge: "merge";
+        squash: "squash";
+        rebase: "rebase";
+        ff: "ff";
+    }>>;
+    message: z.ZodOptional<z.ZodString>;
+    authorName: z.ZodOptional<z.ZodString>;
+    authorEmail: z.ZodOptional<z.ZodString>;
+    ownerOverrideReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrMergeOutputSchema: z.ZodObject<{
+    merged: z.ZodBoolean;
+    sha: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    replayed: z.ZodOptional<z.ZodBoolean>;
+    pullRequest: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        merge: "merge";
+        squash: "squash";
+        rebase: "rebase";
+        ff: "ff";
+    }>>;
+}, z.core.$strip>;
+export declare const ForgeAutoMergeStateSchema: z.ZodEnum<{
+    cancelled: "cancelled";
+    pending: "pending";
+    failed: "failed";
+    processing: "processing";
+    merged: "merged";
+    closed: "closed";
+    retrying: "retrying";
+    stale: "stale";
+}>;
+export declare const ForgeAutoMergePolicyReferenceSchema: z.ZodObject<{
+    mode: z.ZodLiteral<"live">;
+    targetRef: z.ZodString;
+}, z.core.$strict>;
+export declare const ForgeAutoMergeIntentSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    repositoryId: z.ZodUUID;
+    pullRequestNumber: z.ZodNumber;
+    expectedHeadSha: z.ZodString;
+    requestedBy: z.ZodObject<{
+        accountId: z.ZodString;
+        principalId: z.ZodString;
+        principalType: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+        }>;
+    }, z.core.$strict>;
+    requestedByUserId: z.ZodString;
+    strategy: z.ZodEnum<{
+        merge: "merge";
+        squash: "squash";
+        rebase: "rebase";
+        ff: "ff";
+    }>;
+    message: z.ZodOptional<z.ZodString>;
+    authorName: z.ZodOptional<z.ZodString>;
+    authorEmail: z.ZodOptional<z.ZodString>;
+    policyReference: z.ZodObject<{
+        mode: z.ZodLiteral<"live">;
+        targetRef: z.ZodString;
+    }, z.core.$strict>;
+    latestPolicyEvaluation: z.ZodOptional<z.ZodUnknown>;
+    state: z.ZodEnum<{
+        cancelled: "cancelled";
+        pending: "pending";
+        failed: "failed";
+        processing: "processing";
+        merged: "merged";
+        closed: "closed";
+        retrying: "retrying";
+        stale: "stale";
+    }>;
+    attempts: z.ZodNumber;
+    nextAttemptAt: z.ZodISODateTime;
+    lastError: z.ZodOptional<z.ZodString>;
+    terminalReason: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodISODateTime;
+    updatedAt: z.ZodISODateTime;
+    startedAt: z.ZodOptional<z.ZodISODateTime>;
+    completedAt: z.ZodOptional<z.ZodISODateTime>;
+    cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+}, z.core.$strict>;
+export declare const PrAutoMergeEnableInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    expectedHeadSha: z.ZodString;
+    strategy: z.ZodOptional<z.ZodEnum<{
+        merge: "merge";
+        squash: "squash";
+        rebase: "rebase";
+        ff: "ff";
+    }>>;
+    message: z.ZodOptional<z.ZodString>;
+    authorName: z.ZodOptional<z.ZodString>;
+    authorEmail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrAutoMergeGetInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+}, z.core.$strip>;
+export declare const PrAutoMergeIntentOutputSchema: z.ZodObject<{
+    intent: z.ZodObject<{
+        id: z.ZodUUID;
+        repositoryId: z.ZodUUID;
+        pullRequestNumber: z.ZodNumber;
+        expectedHeadSha: z.ZodString;
+        requestedBy: z.ZodObject<{
+            accountId: z.ZodString;
+            principalId: z.ZodString;
+            principalType: z.ZodEnum<{
+                human: "human";
+                agent: "agent";
+            }>;
+        }, z.core.$strict>;
+        requestedByUserId: z.ZodString;
+        strategy: z.ZodEnum<{
+            merge: "merge";
+            squash: "squash";
+            rebase: "rebase";
+            ff: "ff";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+        authorName: z.ZodOptional<z.ZodString>;
+        authorEmail: z.ZodOptional<z.ZodString>;
+        policyReference: z.ZodObject<{
+            mode: z.ZodLiteral<"live">;
+            targetRef: z.ZodString;
+        }, z.core.$strict>;
+        latestPolicyEvaluation: z.ZodOptional<z.ZodUnknown>;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            pending: "pending";
+            failed: "failed";
+            processing: "processing";
+            merged: "merged";
+            closed: "closed";
+            retrying: "retrying";
+            stale: "stale";
+        }>;
+        attempts: z.ZodNumber;
+        nextAttemptAt: z.ZodISODateTime;
+        lastError: z.ZodOptional<z.ZodString>;
+        terminalReason: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodISODateTime;
+        updatedAt: z.ZodISODateTime;
+        startedAt: z.ZodOptional<z.ZodISODateTime>;
+        completedAt: z.ZodOptional<z.ZodISODateTime>;
+        cancelledAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const PrCreateFromBranchInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodString;
+        source: z.ZodString;
+        role: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>>;
+    sourceRef: z.ZodString;
+    targetRef: z.ZodOptional<z.ZodString>;
+    headSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrCreateFromBranchOutputSchema: z.ZodObject<{
+    item: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        repositoryId: z.ZodOptional<z.ZodString>;
+        issueNumber: z.ZodOptional<z.ZodNumber>;
+        type: z.ZodEnum<{
+            task: "task";
+            bug: "bug";
+            research: "research";
+            ops: "ops";
+            doc: "doc";
+            pr: "pr";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            done: "done";
+            blocked: "blocked";
+            draft: "draft";
+            backlog: "backlog";
+            planned: "planned";
+            in_progress: "in_progress";
+            in_review: "in_review";
+            cancelled: "cancelled";
+        }>;
+        priority: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            urgent: "urgent";
+        }>>;
+        effortId: z.ZodOptional<z.ZodUUID>;
+        milestoneId: z.ZodOptional<z.ZodUUID>;
+        ownerParticipantId: z.ZodOptional<z.ZodString>;
+        assignedParticipantId: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            id: z.ZodString;
+            source: z.ZodString;
+            role: z.ZodDefault<z.ZodString>;
+        }, z.core.$strip>>>;
+        pr: z.ZodOptional<z.ZodObject<{
+            sourceRef: z.ZodString;
+            targetRef: z.ZodString;
+            mergeBase: z.ZodOptional<z.ZodString>;
+            headSha: z.ZodOptional<z.ZodString>;
+            mergeCommitSha: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                open: "open";
+                draft: "draft";
+                merged: "merged";
+                closed: "closed";
+            }>;
+            ciStatus: z.ZodOptional<z.ZodEnum<{
+                success: "success";
+                error: "error";
+                pending: "pending";
+                failure: "failure";
+            }>>;
+            stack: z.ZodOptional<z.ZodObject<{
+                id: z.ZodUUID;
+                stackNumber: z.ZodNumber;
+                position: z.ZodNumber;
+                size: z.ZodNumber;
+                trunkRef: z.ZodString;
+                state: z.ZodEnum<{
+                    active: "active";
+                    merged: "merged";
+                    merging: "merging";
+                    dissolved: "dissolved";
+                }>;
+                health: z.ZodEnum<{
+                    clean: "clean";
+                    "restack-required": "restack-required";
+                    conflicted: "conflicted";
+                }>;
+                landingPolicy: z.ZodEnum<{
+                    "batch-allowed": "batch-allowed";
+                    "one-layer-at-a-time": "one-layer-at-a-time";
+                }>;
+                revision: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$loose>>;
+        metadata: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const PrReviewCommentInputSchema: z.ZodObject<{
+    repo: z.ZodString;
+    issueNumber: z.ZodNumber;
+    body: z.ZodString;
+    reviewState: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+        commented: "commented";
+    }>>;
+    reviewPath: z.ZodOptional<z.ZodString>;
+    reviewLine: z.ZodOptional<z.ZodNumber>;
+    reviewSide: z.ZodOptional<z.ZodEnum<{
+        old: "old";
+        new: "new";
+    }>>;
+    reviewCommitSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const PrReviewCommentOutputSchema: z.ZodObject<{
+    comment: z.ZodObject<{
+        id: z.ZodString;
+        projectId: z.ZodOptional<z.ZodString>;
+        itemId: z.ZodOptional<z.ZodString>;
+        authorParticipantId: z.ZodOptional<z.ZodString>;
+        body: z.ZodString;
+        source: z.ZodEnum<{
+            human: "human";
+            agent: "agent";
+            system: "system";
+        }>;
+        sourceSessionId: z.ZodOptional<z.ZodString>;
+        ephemeral: z.ZodOptional<z.ZodBoolean>;
+        reviewPath: z.ZodOptional<z.ZodString>;
+        reviewLine: z.ZodOptional<z.ZodNumber>;
+        reviewSide: z.ZodOptional<z.ZodEnum<{
+            old: "old";
+            new: "new";
+        }>>;
+        reviewCommitSha: z.ZodOptional<z.ZodString>;
+        reviewState: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+            commented: "commented";
+        }>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+/** Repository policy for whether unreported checks block merging. */
+export declare const RequiredChecksPolicySchema: z.ZodEnum<{
+    strict: "strict";
+    permissive: "permissive";
+}>;
+/** Stable error payload emitted when strict policy has no successful checks. */
+export declare const RequiredChecksPolicyBlockSchema: z.ZodObject<{
+    error: z.ZodLiteral<"required-checks-missing">;
+    reason: z.ZodLiteral<"required-checks-missing">;
+    requiredChecksPolicy: z.ZodLiteral<"strict">;
+    detail: z.ZodString;
+    hint: z.ZodString;
+}, z.core.$strip>;
+export type RepoRef = z.infer<typeof RepoRefSchema>;
+export type ListReposInput = z.infer<typeof ListReposInputSchema>;
+export type ListReposOutput = z.infer<typeof ListReposOutputSchema>;
+export type TrackingCommentSource = z.infer<typeof TrackingCommentSourceSchema>;
+export type TrackingReviewSide = z.infer<typeof TrackingReviewSideSchema>;
+export type TrackingReviewState = z.infer<typeof TrackingReviewStateSchema>;
+export type TrackingPrResult = z.infer<typeof TrackingPrResultSchema>;
+export type TrackingItemResult = z.infer<typeof TrackingItemResultSchema>;
+export type TrackingCommentResult = z.infer<typeof TrackingCommentResultSchema>;
+export type IssueCreateInput = z.infer<typeof IssueCreateInputSchema>;
+export type IssueCreateOutput = z.infer<typeof IssueCreateOutputSchema>;
+export type IssueListInput = z.infer<typeof IssueListInputSchema>;
+export type IssueListOutput = z.infer<typeof IssueListOutputSchema>;
+export type IssueGetInput = z.infer<typeof IssueGetInputSchema>;
+export type IssueGetOutput = z.infer<typeof IssueGetOutputSchema>;
+export type IssueUpdateInput = z.infer<typeof IssueUpdateInputSchema>;
+export type IssueUpdateOutput = z.infer<typeof IssueUpdateOutputSchema>;
+export type IssueCloseInput = z.input<typeof IssueCloseInputSchema>;
+export type IssueCloseOutput = z.infer<typeof IssueCloseOutputSchema>;
+export type IssueReopenInput = z.input<typeof IssueReopenInputSchema>;
+export type IssueReopenOutput = z.infer<typeof IssueReopenOutputSchema>;
+export type IssueCommentInput = z.infer<typeof IssueCommentInputSchema>;
+export type IssueCommentOutput = z.infer<typeof IssueCommentOutputSchema>;
+export type ForgeIssueCommentCreateInput = z.infer<typeof ForgeIssueCommentCreateInputSchema>;
+export type IssueCommentsListInput = z.infer<typeof IssueCommentsListInputSchema>;
+export type IssueCommentsListOutput = z.infer<typeof IssueCommentsListOutputSchema>;
+export type IssueSearchInput = z.infer<typeof IssueSearchInputSchema>;
+export type IssueSearchOutput = z.infer<typeof IssueSearchOutputSchema>;
+export type PrCreateInput = z.infer<typeof PrCreateInputSchema>;
+export type PrCreateOutput = z.infer<typeof PrCreateOutputSchema>;
+export type PrListInput = z.infer<typeof PrListInputSchema>;
+export type PrListOutput = z.infer<typeof PrListOutputSchema>;
+export type PrGetInput = z.infer<typeof PrGetInputSchema>;
+export type PrGetOutput = z.infer<typeof PrGetOutputSchema>;
+export type PrUpdateInput = z.infer<typeof PrUpdateInputSchema>;
+export type PrUpdateOutput = z.infer<typeof PrUpdateOutputSchema>;
+export type PrCloseInput = z.input<typeof PrCloseInputSchema>;
+export type PrCloseOutput = z.infer<typeof PrCloseOutputSchema>;
+export type PrReopenInput = z.input<typeof PrReopenInputSchema>;
+export type PrReopenOutput = z.infer<typeof PrReopenOutputSchema>;
+export type PrSearchInput = z.infer<typeof PrSearchInputSchema>;
+export type PrSearchOutput = z.infer<typeof PrSearchOutputSchema>;
+export type PrMergeStatusInput = z.infer<typeof PrMergeStatusInputSchema>;
+export type PrMergeStatusOutput = z.infer<typeof PrMergeStatusOutputSchema>;
+export type PrChangedFile = z.infer<typeof PrChangedFileSchema>;
+export type PrFilesInput = z.infer<typeof PrFilesInputSchema>;
+export type PrFilesOutput = z.infer<typeof PrFilesOutputSchema>;
+export type PrMergeInput = z.infer<typeof PrMergeInputSchema>;
+export type PrMergeOutput = z.infer<typeof PrMergeOutputSchema>;
+export type ForgeAutoMergeState = z.infer<typeof ForgeAutoMergeStateSchema>;
+export type ForgeAutoMergeIntent = z.infer<typeof ForgeAutoMergeIntentSchema>;
+export type PrAutoMergeEnableInput = z.infer<typeof PrAutoMergeEnableInputSchema>;
+export type PrAutoMergeGetInput = z.infer<typeof PrAutoMergeGetInputSchema>;
+export type PrAutoMergeIntentOutput = z.infer<typeof PrAutoMergeIntentOutputSchema>;
+export type PrCreateFromBranchInput = z.infer<typeof PrCreateFromBranchInputSchema>;
+export type PrCreateFromBranchOutput = z.infer<typeof PrCreateFromBranchOutputSchema>;
+export type PrReviewCommentInput = z.infer<typeof PrReviewCommentInputSchema>;
+export type PrReviewCommentOutput = z.infer<typeof PrReviewCommentOutputSchema>;
+export type RequiredChecksPolicy = z.infer<typeof RequiredChecksPolicySchema>;
+export type RequiredChecksPolicyBlock = z.infer<typeof RequiredChecksPolicyBlockSchema>;
+/** Summarize a check list with its worst current state; advisory checks count only when every check is advisory. */
+export declare function aggregateStatusChecks(all: readonly StatusCheck[]): StatusCheckState | undefined;
+/** Read valid status checks from tracking metadata without letting malformed values abort a request. */
+export declare function readStatusChecks(metadata?: unknown): StatusCheck[];
+/** Return every non-success check that blocks a merge. */
+export declare function statusChecksBlockingMerge(checks: readonly StatusCheck[]): StatusCheck[];
+/** Whether any reported check blocks a merge. */
+export declare function statusChecksBlockMerge(checks: readonly StatusCheck[]): boolean;
+/** Replace a check by context and discard checks for a superseded head. */
+export declare function upsertStatusCheck(existing: readonly StatusCheck[], next: StatusCheck): StatusCheck[];
+export type TrackingItemPatchBody = Partial<Pick<IssueUpdateInput, 'type' | 'title' | 'description' | 'priority' | 'effortId' | 'milestoneId' | 'tags' | 'assignedParticipantId' | 'links'>> & {
+    status?: TrackingItemStatus;
+    pr?: TrackingPrResult;
+};
+//# sourceMappingURL=wire-contracts.d.ts.map