@rallycry/conveyor-mcp 4.3.28 → 4.3.30

package/dist/connection-CRkBLz5w.d.ts

@@ -0,0 +1,911 @@
+interface ConveyorMcpConfig {
+    apiUrl: string;
+    projectToken: string;
+    projectId?: string;
+    /**
+     * Optional default board (sub-project) scope. When set, unqualified
+     * task create/list/search default to this board instead of the whole
+     * project — so a connection scoped to a board lands cards on that board.
+     */
+    subProjectId?: string;
+}
+/** Actions a connection is authorized for, mirrors ConveyorCapability in @project/shared. */
+type ConveyorCapability = "read" | "create" | "update" | "chat" | "files" | "build";
+/** Immutable id + human name/slug + web URL for one connection scope level. */
+interface ConnectionScopeRef {
+    id: string;
+    name: string;
+    slug: string;
+    url: string;
+}
+/** Result of `get_connection_context` — effective identity + scope + grants. */
+interface ConnectionContext {
+    account: {
+        userId: string;
+        name: string | null;
+        email: string;
+    };
+    project: ConnectionScopeRef & {
+        githubRepoOwner: string | null;
+        githubRepoName: string | null;
+    };
+    subProject: (ConnectionScopeRef & {
+        rootPath: string | null;
+    }) | null;
+    role: string;
+    capabilities: ConveyorCapability[];
+    managementUrls: {
+        board: string;
+        projectSettings: string;
+        memberSettings: string;
+    };
+    summary: string;
+}
+/** One layer of the verify_connection ladder. */
+interface VerifyConnectionLayer {
+    key: string;
+    label: string;
+    ok: boolean;
+    detail: string;
+}
+/** Result of `verify_connection` — a layered, verify-by-scope probe. */
+interface VerifyConnectionResult {
+    ok: boolean;
+    layers: VerifyConnectionLayer[];
+    summary: string;
+    nextAction: string | null;
+    scope: {
+        projectId: string;
+        projectName: string;
+        subProjectId: string | null;
+        subProjectName: string | null;
+        capabilities: ConveyorCapability[];
+    };
+}
+/** The project + board a task mutation actually landed on. Returned so a caller
+ *  can confirm where the write went (name-vs-board-label ambiguity guard). */
+interface EffectiveScope {
+    projectId: string;
+    subProjectId: string | null;
+}
+/** One board under the connected project, for list_accessible_subprojects. */
+interface AccessibleSubproject {
+    id: string;
+    name: string;
+    slug: string;
+    url: string;
+    rootPath: string | null;
+    role: string;
+    capabilities: ConveyorCapability[];
+}
+/**
+ * Canonical risk levels — kept in lockstep with `RISK_LEVELS` in
+ * `@project/shared` (conveyor-mcp is published standalone and does not depend on
+ * the shared package, so the vocabulary is duplicated here).
+ */
+type RiskLevel = "critical" | "high" | "medium" | "low";
+/** A single PTY output frame broadcast on the `pty:data` room event. */
+interface PtyDataChunk {
+    sessionId: string;
+    seq: number;
+    data: string;
+    cols?: number;
+    rows?: number;
+}
+/** Ring-buffer snapshot returned by `ptyAttach` for catch-up replay. */
+interface PtyAttachSnapshot {
+    sessionId: string;
+    chunks: {
+        seq: number;
+        data: string;
+    }[];
+    cols: number;
+    rows: number;
+    totalBytes: number;
+}
+/**
+ * One card as it appears on the live `cardsByProject` collection. A structural
+ * subset of `TaskCardDTO` — only what `conveyor-wait` filters on and prints, so
+ * the standalone package does not have to mirror the whole board DTO. Note
+ * there is no flat assignee id: the assignee rides the `assignedUser` relation.
+ */
+interface CardCollectionItem {
+    id: string;
+    slug?: string;
+    title?: string;
+    type?: string;
+    status?: string;
+    assignedUser?: {
+        id: string;
+    } | null;
+}
+/** One page of the `cardsByProject` snapshot, as returned by the subscribe ack. */
+interface CardCollectionPage {
+    items: CardCollectionItem[];
+    nextCursor: string | null;
+    totalCount: number;
+}
+/**
+ * A quickdraw collection change on a card scope. `added` vs `updated` is
+ * cosmetic — most card writes go through a hand-rolled upsert that always
+ * emits `updated`, creates included.
+ */
+type CardCollectionDelta = {
+    type: "added";
+    item: CardCollectionItem;
+    rev: number;
+} | {
+    type: "updated";
+    item: CardCollectionItem;
+    rev: number;
+} | {
+    type: "removed";
+    id: string;
+    rev: number;
+} | {
+    type: "reset";
+    rev: number;
+};
+/**
+ * Result of `getActivePtySession`. `sessionId` is null until the cloud agent
+ * has booted a PTY and produced at least one ring frame (readiness signal).
+ */
+interface ActivePtySession {
+    sessionId: string | null;
+    cols?: number;
+    rows?: number;
+}
+interface WorkspaceAttachInfo {
+    taskId: string;
+    sessionId: string;
+    workspaceRoot: string;
+    /** "codespace" means preview-only — GitHub owns the VM's forwarded ports, so
+     *  `tunnelUrl`/`attachToken`/`ssh` are null/absent. Older servers omit it. */
+    backend?: "gke" | "codespace";
+    tunnelUrl: string | null;
+    attachToken: string | null;
+    expiresAt: string;
+    previewPorts: Array<{
+        port: number;
+        label: string;
+    }>;
+    previewUrls: Record<string, string>;
+    ssh?: {
+        remotePort: number;
+        preferredLocalPort: number;
+        username: string;
+    };
+}
+/** One Cloud Logging entry as returned by the API's queryProjectGcpLogs. */
+interface GcpLogEntry {
+    timestamp: string;
+    severity: string;
+    message: string;
+    resource: Record<string, string>;
+    labels: Record<string, string>;
+    resourceType?: string;
+    insertId?: string;
+    trace?: string;
+    httpRequest?: {
+        status?: number;
+        method?: string;
+        url?: string;
+        latencyMs?: number;
+    };
+    payload?: string;
+    payloadTruncated?: boolean;
+}
+interface GcpLogQueryResult {
+    entries: GcpLogEntry[];
+    hasMore: boolean;
+    nextPageToken?: string;
+    scopedServices?: string[];
+    error?: string;
+}
+/** Loki entries normalize onto the same row shape as Cloud Logging entries. */
+interface GrafanaLogQueryResult {
+    entries: GcpLogEntry[];
+    hasMore: boolean;
+    /** The LogQL the server composed or executed — agents can iterate on it. */
+    logql?: string;
+    error?: string;
+}
+/**
+ * One row of the project onboarding checklist. Mirrors the API's
+ * `ReadinessCheck` (conveyor-mcp is published standalone and does not depend on
+ * `@project/shared`, so the shape is duplicated here).
+ */
+interface OnboardingCheck {
+    key: string;
+    status: "ok" | "warn" | "fail";
+    reason: string;
+    fix?: {
+        label: string;
+        href?: string | null;
+        action?: string;
+    };
+}
+/** Result of `get_onboarding_status` — the project's setup readiness report. */
+interface OnboardingStatus {
+    ok: boolean;
+    checks: OnboardingCheck[];
+    bypassedAt: string | null;
+}
+/** The single next onboarding step. Mirrors the API's `OnboardingStep`. */
+interface OnboardingStep {
+    key: string;
+    status: "warn" | "fail";
+    title: string;
+    reason: string;
+    guidance: string;
+    autoFixable: boolean;
+    fix?: {
+        label: string;
+        href?: string | null;
+        action?: string;
+    };
+    connectUrls?: Record<string, string>;
+}
+/** Result of `get_onboarding_step` — the choose-your-own-adventure step driver.
+ *  Mirrors the API's `OnboardingStepReport`. */
+interface OnboardingStepReport {
+    done: boolean;
+    ok: boolean;
+    bypassedAt: string | null;
+    step: OnboardingStep | null;
+    remaining: Array<{
+        key: string;
+        status: "warn" | "fail";
+        reason: string;
+    }>;
+    checks: OnboardingCheck[];
+}
+/** Result of `set_task_parent` — mirrors the API's `ReparentCardResult`. */
+interface SetTaskParentResult {
+    id: string;
+    slug: string;
+    status: string;
+    previousParentTaskId: string | null;
+    parentTaskId: string | null;
+    parentSlug: string | null;
+    /** Conditions reported rather than enforced: the move landed regardless. */
+    warnings: string[];
+}
+interface MoveCardResult {
+    cardId: string;
+    sourceProjectId: string;
+    destinationProjectId: string;
+    slug: string;
+    clearedFields: string[];
+}
+interface ProjectConnectUrls {
+    gcpConnect: string;
+    gcpSettings: string;
+    memberSettings: string;
+    projectSettings: string;
+    setupWizard: string;
+}
+interface TagSummary {
+    id: string;
+    name: string;
+    color: string;
+    description?: string | null;
+}
+/** A tag context-path link (rule/doc/file/folder) loaded into agent context.
+ *  A locator turns the link into a VERIFIED repo link — mirrors
+ *  TagContextLink in @project/shared types/tag-types.ts. */
+interface ContextPathInput {
+    type: "rule" | "doc" | "file" | "folder";
+    path: string;
+    label?: string;
+    locator?: string;
+    locatorType?: "test" | "code";
+}
+interface PrioritySummary {
+    id: string;
+    value: number;
+    name: string;
+    color: string;
+    description?: string | null;
+}
+declare class ConveyorConnection {
+    private socket;
+    private config;
+    /** project slug → id, for resolving `<project>/<card>` card paths. */
+    private projectSlugIds;
+    constructor(config: ConveyorMcpConfig);
+    get projectId(): string;
+    private resolveProjectId;
+    /** The configured default board (CONVEYOR_SUBPROJECT_ID), if any. */
+    get defaultSubProjectId(): string | undefined;
+    /**
+     * Resolve the board scope for a task create/list/search:
+     * - `null` explicitly means "the whole project" (never fall back to the default).
+     * - `undefined` (not passed) falls back to the connection's default board.
+     * - a concrete id is used as-is.
+     * Returning `undefined` leaves the request unscoped (whole project).
+     */
+    private resolveSubProjectId;
+    private normalizeProjectList;
+    connect(): Promise<void>;
+    private call;
+    /**
+     * Fire-and-forget emit (no ack). The quickdraw-core server method handler
+     * invokes the ack callback via optional chaining, so omitting it still runs
+     * the full auth/schema/ACL pipeline — it just skips the response round-trip.
+     * Used for high-frequency PTY input/resize so each keystroke does not arm a
+     * 15s timeout timer.
+     */
+    private emit;
+    private callService;
+    queryGcpLogs(params: {
+        projectId?: string;
+        env?: "prod" | "dev" | "claudespace";
+        severity?: string;
+        services?: string[];
+        sqlInstances?: string[];
+        allServices?: boolean;
+        search?: string;
+        filter?: string;
+        startTime?: string;
+        endTime?: string;
+        limit?: number;
+        pageToken?: string;
+    }): Promise<GcpLogQueryResult>;
+    queryGrafanaLogs(params: {
+        projectId?: string;
+        env?: "prod" | "dev";
+        services?: string[];
+        level?: "debug" | "info" | "warn" | "error" | "fatal";
+        search?: string;
+        logql?: string;
+        startTime?: string;
+        endTime?: string;
+        limit?: number;
+    }): Promise<GrafanaLogQueryResult>;
+    listTasks(params: {
+        projectId?: string;
+        status?: string;
+        typeFilters?: string[];
+        assigneeId?: string;
+        unassigned?: boolean;
+        subProjectId?: string | null;
+        limit?: number;
+    }): Promise<unknown[]>;
+    getTask(taskId: string, projectId?: string): Promise<unknown>;
+    getCardBySlug(slug: string, projectId?: string): Promise<unknown>;
+    searchTasks(params: {
+        projectId?: string;
+        tagNames?: string[];
+        tagMatch?: "any" | "all";
+        includeChildTags?: boolean;
+        searchQuery?: string;
+        statusFilters?: string[];
+        typeFilters?: string[];
+        assigneeId?: string;
+        unassigned?: boolean;
+        subProjectId?: string | null;
+        limit?: number;
+    }): Promise<unknown[]>;
+    createTask(params: {
+        projectId?: string;
+        title: string;
+        description?: string;
+        plan?: string;
+        status?: string;
+        subProjectId?: string | null;
+        tags?: string[];
+    }): Promise<{
+        id: string;
+        slug: string;
+        effectiveScope: EffectiveScope;
+    }>;
+    updateTask(params: {
+        projectId?: string;
+        taskId: string;
+        title?: string;
+        description?: string;
+        plan?: string;
+        status?: string;
+        risk?: RiskLevel | null;
+        storyPointValue?: number | null;
+        assignedUserId?: string | null;
+        subProjectId?: string | null;
+        githubBranch?: string | null;
+        addTags?: string[];
+        removeTags?: string[];
+    }): Promise<{
+        id: string;
+        status: string | null;
+        risk: RiskLevel | null;
+        storyPointValue: number | null;
+        assignedUserId: string | null;
+        addedTags: string[];
+        removedTags: string[];
+    }>;
+    /** Resolve tag names to IDs within a project, throwing on any unknown name. */
+    private resolveTagIds;
+    private assignTagsToTask;
+    private removeTagsFromTask;
+    /** Guarded status transition used by the review tools (approve/request). */
+    transitionTaskStatus(params: {
+        projectId?: string;
+        taskId: string;
+        toStatus: string;
+        expectedFromStatus?: string;
+        risk?: RiskLevel;
+    }): Promise<{
+        id: string;
+        status: string;
+        risk: RiskLevel | null;
+    }>;
+    moveCard(params: {
+        projectId?: string;
+        taskId: string;
+        destinationProjectId: string;
+    }): Promise<MoveCardResult>;
+    addReviewer(params: {
+        projectId?: string;
+        taskId: string;
+        userId: string;
+    }): Promise<{
+        taskId: string;
+        reviewers: Array<{
+            userId: string;
+            name: string | null;
+        }>;
+    }>;
+    removeReviewer(params: {
+        projectId?: string;
+        taskId: string;
+        userId: string;
+    }): Promise<{
+        taskId: string;
+        reviewers: Array<{
+            userId: string;
+            name: string | null;
+        }>;
+    }>;
+    listProjectMembers(projectId?: string): Promise<Array<{
+        userId: string;
+        name: string | null;
+        email: string;
+        level: string;
+    }>>;
+    listProjects(): Promise<unknown[]>;
+    /**
+     * Resolve a project SLUG (as pasted in a `<project>/<card>` card path) to its
+     * id.
+     *
+     * Cached, because a slug→id mapping effectively never changes and this sits
+     * in front of an ordinary card lookup. A miss refetches once before failing,
+     * so a project created after the cache warmed still resolves.
+     *
+     * Throws naming the slug rather than falling back to the configured default
+     * project: the caller pasted a specific project, and silently answering about
+     * a different one is the worst possible outcome here.
+     */
+    resolveProjectIdBySlug(slug: string): Promise<string>;
+    private refreshProjectSlugCache;
+    startBuild(taskId: string, projectId?: string): Promise<{
+        taskId: string;
+        status: string;
+    }>;
+    stopBuild(taskId: string, projectId?: string): Promise<{
+        taskId: string;
+        stopped: boolean;
+    }>;
+    sleepTask(taskId: string, projectId?: string): Promise<{
+        taskId: string;
+        codespaceStatus: string;
+    }>;
+    resumeTask(taskId: string, projectId?: string): Promise<{
+        status: string;
+    }>;
+    deleteTaskEnvironment(taskId: string, projectId?: string): Promise<{
+        taskId: string;
+        status: string;
+    }>;
+    getBuildStatus(taskId: string, projectId?: string): Promise<{
+        session: {
+            status: string | null;
+            agentRunnerStatus: string | null;
+        } | null;
+    }>;
+    getWorkspaceAttachInfo(taskId: string, sshPublicKey?: string): Promise<WorkspaceAttachInfo>;
+    getTaskChat(taskId: string, limit?: number, projectId?: string): Promise<unknown[]>;
+    postToTaskChat(taskId: string, content: string, projectId?: string): Promise<{
+        messageId: string;
+    }>;
+    getTaskCli(taskId: string, limit?: number, source?: string, projectId?: string): Promise<{
+        type: string;
+        data: Record<string, unknown>;
+        timestamp: string;
+    }[]>;
+    getTaskSessions(taskId: string, projectId?: string): Promise<Array<{
+        taskId: string;
+        slug: string;
+        title: string;
+        type: string;
+        status: string;
+        codeReviewStatus: string | null;
+        codeReviewAttempts: number;
+        workspaces: Array<{
+            id: string;
+            purpose: string;
+            desiredState: string;
+            observedState: string;
+            branch: string | null;
+            checkoutRef: string | null;
+            createdAt: string;
+            updatedAt: string;
+            pod: {
+                name: string;
+                namespace: string;
+                phase: string;
+                imageUri: string | null;
+            } | null;
+            sessions: Array<{
+                id: string;
+                role: string;
+                mode: string;
+                status: string;
+                userId: string;
+                leaseUntil: string | null;
+                createdAt: string;
+            }>;
+        }>;
+        sessions: Array<{
+            id: string;
+            provider: string;
+            instanceName: string | null;
+            status: string;
+            agentRunnerStatus: string | null;
+            lastHeartbeatAt: string | null;
+            agentRunningAt: string | null;
+            lastAgentEvent: string | null;
+            deletionRequestedAt: string | null;
+            deletionAttempts: number;
+            createdAt: string;
+            stoppedAt: string | null;
+        }>;
+    }>>;
+    listTags(projectId?: string): Promise<{
+        id: string;
+        name: string;
+        color: string;
+        description: string | null;
+        parentTagIds: string[];
+        childTagIds: string[];
+        hasOverview: boolean;
+        /** Files labelled as examples of the tag — read the tiles with list_tag_attachments. */
+        attachmentCount: number;
+        /** Rule/doc/file/folder links the tag wires into agent context; `[]` when none. */
+        contextPaths: ContextPathInput[];
+    }[]>;
+    getTag(params: {
+        projectId?: string;
+        tag: string;
+    }): Promise<unknown>;
+    /** One page of a tag's attachment gallery, newest label first. */
+    listTagAttachments(params: {
+        projectId?: string;
+        tag: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown>;
+    /** Replace the glossary tags on a file that is already uploaded. */
+    setFileTags(params: {
+        projectId?: string;
+        taskId: string;
+        fileId: string;
+        tags: string[];
+    }): Promise<{
+        fileId: string;
+        fileName: string;
+        appliedTags?: string[];
+        unknownTags?: string[];
+    }>;
+    getProjectSummary(projectId?: string): Promise<unknown>;
+    /** Effective account/project/board identity + capabilities for this token. */
+    getConnectionContext(projectId?: string): Promise<ConnectionContext>;
+    /** Layered verify-by-scope probe (auth → account → project → board →
+     *  capabilities → read). Proves create/update on the intended board. */
+    verifyConnection(params?: {
+        projectId?: string;
+        intendedActions?: ConveyorCapability[];
+    }): Promise<VerifyConnectionResult>;
+    /** Boards under the connected project with id/name/slug/url/role/capabilities. */
+    listAccessibleSubprojects(projectId?: string): Promise<AccessibleSubproject[]>;
+    getOnboardingStatus(projectId?: string): Promise<OnboardingStatus>;
+    getOnboardingStep(projectId?: string): Promise<OnboardingStepReport>;
+    approveTask(taskId: string, projectId?: string, risk?: RiskLevel): Promise<{
+        status: string;
+    }>;
+    requestChanges(taskId: string, feedback: string, projectId?: string, risk?: RiskLevel): Promise<void>;
+    approveAndMergePR(childTaskId: string, projectId?: string): Promise<{
+        merged: boolean;
+        childTaskId: string;
+        prNumber: number;
+    }>;
+    listTaskFiles(taskId: string, projectId?: string): Promise<unknown[]>;
+    getAttachment(taskId: string, fileId: string, opts?: {
+        offset?: number;
+        maxBytes?: number;
+        projectId?: string;
+    }): Promise<unknown>;
+    requestFileUpload(taskId: string, params: {
+        fileName: string;
+        mimeType: string;
+        fileSize: number;
+        projectId?: string;
+    }): Promise<{
+        fileId: string;
+        uploadUrl: string;
+    }>;
+    confirmFileUpload(taskId: string, fileId: string, comment?: string, projectId?: string, tags?: string[]): Promise<{
+        fileId: string;
+        fileName: string;
+        downloadUrl?: string;
+        messageId?: string;
+        appliedTags?: string[];
+        unknownTags?: string[];
+    }>;
+    createRelease(taskIds?: string[], projectId?: string): Promise<{
+        taskId: string;
+        version: string;
+    }>;
+    addTasksToRelease(taskIds: string[], projectId?: string): Promise<{
+        releaseTaskId: string;
+        added: number;
+        releaseBranchUpdated: boolean;
+    }>;
+    createPullRequest(params: {
+        projectId?: string;
+        taskId: string;
+        title: string;
+        body: string;
+        head?: string;
+        base?: string;
+    }): Promise<{
+        prNumber: number;
+        prUrl: string;
+    }>;
+    createSubtask(params: {
+        projectId?: string;
+        parentTaskId: string;
+        title: string;
+        description?: string;
+        plan?: string;
+        ordinal?: number;
+        storyPointValue?: number;
+        followParentStatus?: boolean;
+        dependsOn?: string[];
+        tags?: string[];
+    }): Promise<{
+        id: string;
+        slug: string;
+    }>;
+    /**
+     * Move a card under a new parent, or detach it with an explicit null.
+     * `parentTaskId` rides the rest-spread rather than a conditional one so a
+     * null survives the call — stripping it would silently no-op a detach.
+     */
+    setTaskParent(params: {
+        projectId?: string;
+        taskId: string;
+        parentTaskId: string | null;
+        ordinal?: number;
+        followParentStatus?: boolean;
+    }): Promise<SetTaskParentResult>;
+    updateSubtask(params: {
+        projectId?: string;
+        subtaskId: string;
+        title?: string;
+        description?: string;
+        plan?: string;
+        status?: string;
+        ordinal?: number;
+        storyPointValue?: number;
+        followParentStatus?: boolean;
+        dependsOn?: string[];
+    }): Promise<{
+        id: string;
+        status: string;
+    }>;
+    listSubtasks(taskId: string, projectId?: string): Promise<unknown[]>;
+    deleteSubtask(subtaskId: string, projectId?: string): Promise<{
+        deleted: boolean;
+    }>;
+    getDependencies(taskId: string, projectId?: string): Promise<unknown[]>;
+    addDependency(params: {
+        projectId?: string;
+        taskId: string;
+        dependsOnSlugOrId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    removeDependency(params: {
+        projectId?: string;
+        taskId: string;
+        dependsOnSlugOrId: string;
+    }): Promise<{
+        success: boolean;
+    }>;
+    listManualTests(taskId: string, projectId?: string): Promise<Array<{
+        id: string;
+        type: string;
+        title: string;
+        ordinal: number;
+        createdAt: string;
+        checked: boolean;
+        failures: Array<{
+            userName: string | null;
+            reason: string | null;
+            createdAt: string;
+        }>;
+    }>>;
+    setManualTests(taskId: string, items: Array<{
+        title: string;
+    }>, projectId?: string): Promise<{
+        created: number;
+        skipped: number;
+    }>;
+    editManualTest(taskId: string, title: string, newTitle: string, projectId?: string): Promise<{
+        updated: boolean;
+    }>;
+    removeManualTest(taskId: string, title: string, projectId?: string): Promise<{
+        removed: boolean;
+    }>;
+    approveManualTest(taskId: string, title: string, projectId?: string): Promise<{
+        approved: boolean;
+    }>;
+    rejectManualTest(taskId: string, title: string, reason: string, projectId?: string): Promise<{
+        rejected: boolean;
+    }>;
+    queryManualTests(params: {
+        projectId?: string;
+        cardStatuses?: string[];
+        testStatuses?: Array<"open" | "approved" | "rejected">;
+    }): Promise<Array<{
+        taskId: string;
+        slug: string;
+        title: string;
+        status: string;
+        tests: Array<{
+            id: string;
+            title: string;
+            status: "open" | "approved" | "rejected";
+            failures: Array<{
+                userName: string | null;
+                reason: string | null;
+                createdAt: string;
+            }>;
+        }>;
+    }>>;
+    getConnectUrls(projectId?: string): Promise<ProjectConnectUrls>;
+    updateProjectConfig(params: {
+        projectId?: string;
+        name?: string;
+        description?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<unknown>;
+    updateProjectAgentDefaults(params: {
+        projectId?: string;
+        defaultPmAgentId?: string | null;
+        defaultTaskAgentId?: string | null;
+        defaultReviewerAgentId?: string | null;
+        helperAgentId?: string | null;
+    }): Promise<unknown>;
+    listTagsDetailed(projectId?: string): Promise<TagSummary[]>;
+    createTag(params: {
+        projectId?: string;
+        name: string;
+        color?: string;
+        description?: string;
+        overview?: string;
+        /** Repo file to source the overview from (stored overview stays as the pending fallback). */
+        overviewPath?: string;
+        /** Parents to link at create time (multi-parent DAG). */
+        parentTagIds?: string[];
+        contextPaths?: ContextPathInput[];
+    }): Promise<{
+        id: string;
+    }>;
+    updateTag(params: {
+        id: string;
+        name?: string;
+        color?: string;
+        description?: string;
+        overview?: string | null;
+        /** Repo file to source the overview from; null clears back to the stored overview. */
+        overviewPath?: string | null;
+        parentTagIds?: string[];
+        reason?: string;
+        contextPaths?: ContextPathInput[];
+    }): Promise<unknown>;
+    deleteTag(id: string): Promise<unknown>;
+    previewTagMerge(params: {
+        sourceTagId: string;
+        targetTagId: string;
+    }): Promise<unknown>;
+    mergeTag(params: {
+        sourceTagId: string;
+        targetTagId: string;
+        reason?: string;
+    }): Promise<unknown>;
+    listPriorities(projectId?: string): Promise<PrioritySummary[]>;
+    createPriority(params: {
+        projectId?: string;
+        value: number;
+        name: string;
+        color: string;
+        description?: string;
+    }): Promise<{
+        id: string;
+    }>;
+    updatePriority(params: {
+        id: string;
+        value?: number;
+        name?: string;
+        color?: string;
+        description?: string;
+    }): Promise<unknown>;
+    deletePriority(id: string): Promise<unknown>;
+    createSuggestion(params: {
+        projectId?: string;
+        title: string;
+        description?: string;
+        tagNames?: string[];
+    }): Promise<{
+        id: string;
+        merged: boolean;
+        mergedIntoId?: string;
+    }>;
+    /**
+     * Poll target: returns the active cloud PTY session for a task once its ring
+     * buffer has frames. `sessionId` is resolved server-side from `taskId` (never
+     * accepted from the wire), preserving the one-active-session-per-task invariant.
+     */
+    getActivePtySession(taskId: string): Promise<ActivePtySession>;
+    /** Fetch the ring-buffer snapshot for catch-up replay on (re)attach. */
+    ptyAttach(sessionId: string): Promise<PtyAttachSnapshot>;
+    /**
+     * Join the session room so `pty:data` frames are delivered. Uses the standard
+     * quickdraw-core subscribe envelope; "Read" is sufficient for output streaming.
+     */
+    subscribeToSession(sessionId: string): void;
+    /** Relay a stdin chunk to the cloud PTY (raw utf8, fire-and-forget). */
+    ptyInput(sessionId: string, data: string): void;
+    /** Relay a terminal resize to the cloud PTY (fire-and-forget). */
+    ptyResize(sessionId: string, cols: number, rows: number): void;
+    /** Subscribe to raw PTY output frames. Returns an unsubscribe function. */
+    onPtyData(handler: (chunk: PtyDataChunk) => void): () => void;
+    /**
+     * Fetch one page of a project's live card collection.
+     *
+     * A cursor-less call also joins the scope room, which is what starts (or
+     * restarts, after a reconnect) delta delivery. Cursor-bearing calls are pure
+     * paging and join nothing, so always lead with the cursor-less call.
+     */
+    subscribeToCardCollection(projectId: string, opts?: {
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<CardCollectionPage>;
+    /**
+     * Listen for card collection deltas on a project scope. The event name is
+     * the room name by design — no id parsing client-side. Returns an
+     * unsubscribe function.
+     */
+    onCardDelta(projectId: string, handler: (delta: CardCollectionDelta) => void): () => void;
+    /**
+     * Run `handler` on every reconnect of the underlying socket. A reconnect
+     * drops every room this socket had joined, so long-lived subscribers must
+     * re-subscribe and reconcile whatever they missed. Returns an unsubscribe
+     * function.
+     */
+    onReconnect(handler: () => void): () => void;
+    disconnect(): void;
+}
+
+export { type ActivePtySession as A, type CardCollectionPage as C, type PtyAttachSnapshot as P, type CardCollectionDelta as a, type CardCollectionItem as b, type PtyDataChunk as c, ConveyorConnection as d, type ConveyorMcpConfig as e };