@nestos/kanban 0.0.0-stage → 0.5.2

package/dist/planning-CHrOqQ6b.d.ts

@@ -0,0 +1,879 @@
+type KanbanSuggestionKind = 'item' | 'parent' | 'dependency' | 'area' | 'milestone' | 'decision' | 'session';
+interface KanbanSuggestionQuery {
+    kind: KanbanSuggestionKind;
+    search?: string;
+    limit?: number;
+    excludeItemId?: string;
+    excludeIds?: string[];
+    childKind?: string;
+}
+interface KanbanSuggestion {
+    id: string;
+    label: string;
+    detail?: string;
+    status?: KanbanItem['status'];
+    archived?: boolean;
+}
+interface KanbanSuggestionPage {
+    revision: number;
+    items: KanbanSuggestion[];
+    hasMore: boolean;
+}
+
+interface KanbanReferenceTarget {
+    boardId: string;
+    itemId?: string;
+    recordId?: string;
+    reference: string;
+    scope: KanbanBoard['scope'];
+}
+declare function kanbanReference(board: {
+    id: string;
+    number?: number;
+}, entity?: {
+    id: string;
+    number?: number;
+    kind?: 'log' | 'decision';
+}): string;
+
+interface KanbanArtifactRef {
+    name: string;
+    ref: string;
+    sha256: string;
+    bytes: number;
+}
+interface KanbanWorkDefinition {
+    expectedRevision?: number;
+    workType?: string;
+    externalRefs?: KanbanExternalReference[];
+    id: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    assignee: KanbanPrincipal;
+    dependsOn: string[];
+    inputs?: Record<string, {
+        fromItemId: string;
+        output: string;
+    }>;
+    outputs?: string[];
+}
+interface KanbanWorkPlan {
+    schema: 'kanban.plan/1';
+    id: string;
+    revision: number;
+    decisionId?: string;
+    rootItemId?: string;
+    sealed: boolean;
+    items: KanbanWorkDefinition[];
+}
+interface KanbanPublishedPlan extends Omit<KanbanWorkPlan, 'items'> {
+    itemIds: string[];
+    definitions: Record<string, {
+        digest: string;
+        inputs: KanbanWorkDefinition['inputs'];
+        outputs: string[];
+    }>;
+}
+interface KanbanDispatch {
+    continuation?: {
+        previousDispatchId: string;
+        instruction?: string;
+    };
+    controlCapabilities?: {
+        pause: 'boundary' | 'none';
+        resume: boolean;
+    };
+    executionSessionId?: string;
+    id: string;
+    itemId: string;
+    itemRevision: number;
+    planId: string;
+    planRevision: number;
+    principal: KanbanPrincipal;
+    definitionDigest: string;
+    attempt: number;
+    fence: string;
+    preparedAt: number;
+    outcome: 'prepared' | 'running' | 'unknown' | 'succeeded' | 'failed' | 'cancelled' | 'accepted' | 'rejected';
+    inputs: Record<string, KanbanArtifactRef>;
+    outputs?: KanbanArtifactRef[];
+    code?: string;
+}
+interface KanbanWorkflowState {
+    plans: Record<string, KanbanPublishedPlan>;
+    dispatches: Record<string, KanbanDispatch>;
+    ready: string[];
+    completedPlans: string[];
+}
+type KanbanWorkflowCommand = {
+    type: 'continue-execution';
+    previousDispatchId: string;
+    dispatchId: string;
+    instruction?: string;
+} | {
+    type: 'publish-plan';
+    plan: KanbanWorkPlan;
+} | {
+    type: 'prepare-dispatch';
+    itemId: string;
+    dispatchId: string;
+    trigger?: 'manual' | 'automatic';
+    estimate?: KanbanEstimate;
+} | {
+    type: 'observe-execution';
+    dispatchId: string;
+    fence: string;
+    outcome: 'running' | 'unknown' | 'succeeded' | 'failed' | 'cancelled';
+    outputs?: KanbanArtifactRef[];
+    code?: string;
+    executionSessionId?: string;
+    controlCapabilities?: {
+        pause: 'boundary' | 'none';
+        resume: boolean;
+    };
+} | {
+    type: 'accept-execution';
+    dispatchId: string;
+    accept: boolean;
+};
+
+interface KanbanBoardControl {
+    mode: 'automatic' | 'manual';
+    paused: boolean;
+    controls: Record<string, string>;
+}
+/** Manual mode still honors an explicit per-task run request. */
+declare function boardAllowsStart(board: Pick<KanbanBoard, 'executionControl' | 'lifecycle'>, item?: Pick<KanbanItem, 'launch'>): boolean;
+declare function boardControlPhase(board: Pick<KanbanBoard, 'executionControl' | 'lifecycle'> & {
+    items: Array<Pick<KanbanItem, 'id' | 'status' | 'control'>>;
+}): 'automatic' | 'manual' | 'pausing' | 'paused' | 'resuming' | 'error' | 'cancelling' | 'cancelled' | 'waiting-deletion';
+
+interface KanbanLaunch {
+    mode?: 'automatic' | 'manual';
+    startAt: number;
+    analysisEpoch?: string;
+    requestedAt?: number;
+    admittedAt?: number;
+    editing?: {
+        id: string;
+        principal: KanbanPrincipal;
+        expiresAt: number;
+    };
+}
+interface KanbanTaskControl {
+    id: string;
+    dispatchId?: string;
+    action: 'pause' | 'resume' | 'cancel';
+    state: 'requested' | 'accepted' | 'paused' | 'resumed' | 'cancelled' | 'failed' | 'unknown';
+    code?: string;
+}
+interface KanbanTaskIssue {
+    id: string;
+    attemptId: string;
+    type: 'clarification' | 'error';
+    resolvedBy?: string;
+}
+type KanbanTaskPhase = 'waiting-start' | 'analyzing' | 'queued' | 'waiting-dependency' | 'preparing' | 'running' | 'cancelling' | 'pausing' | 'paused' | 'resuming' | 'waiting-input' | 'error' | 'review' | 'completed' | 'cancelled' | 'unknown';
+interface KanbanTaskProjection {
+    phase: KanbanTaskPhase;
+    reason?: string;
+    startAt?: number;
+    sessionId?: string;
+    dispatchId?: string;
+    actions: Array<'delete' | 'run' | 'edit' | 'cancel' | 'pause' | 'resume' | 'fix' | 'open-session' | 'resolve' | 'review'>;
+}
+type KanbanTaskCommand = {
+    type: 'begin-edit';
+    itemId: string;
+    editId: string;
+    leaseMs: number;
+} | {
+    type: 'end-edit';
+    itemId: string;
+    editId: string;
+} | {
+    type: 'save-edit';
+    itemId: string;
+    editId: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    planning: KanbanPlanning;
+    launchMode?: 'automatic' | 'manual';
+    externalRefs?: KanbanExternalReference[];
+} | {
+    type: 'retry-analysis';
+    itemId: string;
+    retryId: string;
+} | {
+    type: 'set-launch-mode';
+    itemId: string;
+    mode: 'automatic' | 'manual';
+} | {
+    type: 'request-run';
+    itemId: string;
+} | {
+    type: 'admit-item';
+    itemId: string;
+    trigger: 'manual' | 'automatic';
+} | {
+    type: 'report-analysis';
+    itemId: string;
+    operationId: string;
+    status: KanbanAnalysisStatus;
+} | {
+    type: 'request-control';
+    itemId: string;
+    controlId: string;
+    action: 'pause' | 'resume' | 'cancel';
+} | {
+    type: 'control-receipt';
+    itemId: string;
+    controlId: string;
+    state: KanbanTaskControl['state'];
+    code?: string;
+} | {
+    type: 'report-issue';
+    itemId: string;
+    issue: KanbanTaskIssue;
+} | {
+    type: 'resolve-issue';
+    itemId: string;
+    issueId: string;
+    attemptId: string;
+    resolvedBy: string;
+};
+interface KanbanFixSession {
+    code?: string;
+    id: string;
+    boardId: string;
+    itemId: string;
+    sessionId: string;
+    state: 'clarifying' | 'frozen' | 'accepted' | 'cancelling' | 'cancelled';
+    createdItemId?: string;
+}
+
+interface KanbanSourceRef {
+    sessionId: string;
+    messageId: string;
+    revision: string;
+    role: 'user' | 'assistant';
+}
+interface KanbanDiscoveryChange {
+    action: 'create' | 'update' | 'link';
+    itemId: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    eligibleAgentIds?: string[];
+    eligiblePrincipals?: KanbanPrincipal[];
+    sources: KanbanSourceRef[];
+    planning?: KanbanPlanning;
+}
+interface KanbanDiscoveryBatch {
+    records?: KanbanRecordInput[];
+    runId: string;
+    leaseToken: string;
+    changes: KanbanDiscoveryChange[];
+    checkpoints: Array<{
+        sessionId: string;
+        revision: string;
+    }>;
+    autoCreate: boolean;
+}
+
+interface KanbanText {
+    title: string;
+    responsibility: string;
+    acceptance: string;
+}
+interface KanbanAmendment {
+    runId: string;
+    id: string;
+    fingerprint: string;
+    baseRevision: number;
+    baseDigest: string;
+    proposed: KanbanText;
+    proposedBy: KanbanPrincipal;
+    sources: KanbanSourceRef[];
+    createdAt: number;
+    status: 'pending' | 'accepted' | 'rejected';
+    reviewedAt?: number;
+    reviewedBy?: KanbanPrincipal;
+    reason?: string;
+}
+interface KanbanRecordActivity {
+    actor?: KanbanPrincipal;
+    stage: string;
+    result: 'success' | 'failure' | 'cancelled';
+    dispatchId?: string;
+    code?: string;
+    fields?: Record<string, string | number>;
+}
+interface KanbanProjectRecord {
+    /** Immutable, host-projected activity; decisions remain in the coordination store. */
+    activity?: KanbanRecordActivity;
+    externalRefs?: KanbanExternalReference[];
+    coordination?: {
+        manager: KanbanPrincipal;
+        executor?: KanbanPrincipal;
+    };
+    number?: number;
+    originRunId?: string;
+    id: string;
+    kind: 'log' | 'decision';
+    title: string;
+    content: string;
+    rationale?: string;
+    deletedAt?: number;
+    status: 'draft' | 'confirmed' | 'rejected' | 'superseded' | 'cancelling' | 'cancelled';
+    itemIds: string[];
+    sources: KanbanSourceRef[];
+    author: KanbanPrincipal;
+    origin: 'manual' | 'flow';
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    reviewedBy?: KanbanPrincipal;
+    supersedes?: string;
+    supersededBy?: string;
+}
+type KanbanRecordInput = Pick<KanbanProjectRecord, 'id' | 'kind' | 'title' | 'content' | 'rationale' | 'itemIds' | 'sources' | 'supersedes' | 'coordination' | 'externalRefs'>;
+type KanbanRecordSummary = Omit<KanbanProjectRecord, 'content' | 'rationale' | 'sources'> & {
+    sessionIds: string[];
+};
+interface KanbanRecordQuery {
+    includeDeleted?: boolean;
+    kind?: KanbanProjectRecord['kind'];
+    itemId?: string;
+    status?: KanbanProjectRecord['status'];
+    limit?: number;
+    cursor?: string;
+}
+interface KanbanRecordPage {
+    revision: number;
+    total: number;
+    items: KanbanRecordSummary[];
+    nextCursor?: string;
+}
+
+interface KanbanActor {
+    kind?: KanbanPrincipal['kind'];
+    id?: string;
+    agentId?: string;
+    sessionId?: string;
+    taskId?: string;
+}
+interface KanbanEstimate {
+    complexity: number;
+    workUnits: number;
+    durationMs: number;
+    confidence: 'low' | 'medium' | 'high';
+}
+interface KanbanPolicy {
+    maxInProgressPerAssignee?: number;
+    requireEstimate?: boolean;
+    review?: 'independent' | 'assignee';
+    maxReady?: number;
+    maxInProgress?: number;
+    maxInProgressPerAgent?: number;
+    archiveAfterMs?: number;
+    backlogReviewMs?: number;
+    claimTimeoutMs: number;
+    leaseMs: number;
+    progressTimeoutMs: number;
+    transferTimeoutMs: number;
+    maxComplexity: number;
+    maxWorkUnits: number;
+    maxDurationMs: number;
+    escalationSessionIds: string[];
+}
+interface KanbanParticipant {
+    sessionId: string;
+    agentId?: string;
+    roles: Array<'creator' | 'owner' | 'consultant' | 'reviewer' | 'observer' | 'escalation'>;
+    joinedAt: number;
+    subscribed: boolean;
+}
+interface KanbanAssignment extends KanbanActor {
+    principalId?: string;
+    token: string;
+    leaseUntil: number;
+    claimedAt: number;
+}
+interface KanbanItem {
+    launch?: KanbanLaunch;
+    analysis?: KanbanAnalysisStatus;
+    control?: KanbanTaskControl;
+    issues?: KanbanTaskIssue[];
+    deletedAt?: number;
+    number?: number;
+    origin?: {
+        kind: 'direct' | 'discovery';
+        principal: KanbanPrincipal;
+        runId?: string;
+        fingerprint?: string;
+    };
+    amendments?: KanbanAmendment[];
+    id: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+    eligibleAgentIds?: string[];
+    eligiblePrincipals?: KanbanPrincipal[];
+    status: 'proposed' | 'backlog' | 'open' | 'claimed' | 'review' | 'completed' | 'cancelled';
+    revision: number;
+    createdAt: number;
+    readyAt: number;
+    updatedAt: number;
+    progressAt?: number;
+    owner?: KanbanAssignment;
+    estimate?: KanbanEstimate;
+    workUnits: number;
+    resultRef?: string;
+    transfer?: {
+        id: string;
+        agentId?: string;
+        target?: KanbanPrincipal;
+        requestedAt: number;
+        expiresAt: number;
+    };
+    participants: KanbanParticipant[];
+    sources?: KanbanSourceRef[];
+    externalRefs?: KanbanExternalReference[];
+    blocked?: {
+        reason: string;
+        at: number;
+    };
+    planning?: KanbanPlanning;
+    closedAt?: number;
+    restoredAt?: number;
+    closureReason?: string;
+}
+interface KanbanBoard {
+    lifecycle?: {
+        operationId: string;
+        intent: 'cancel' | 'delete';
+        mode: 'drain' | 'cancel';
+        phase: 'waiting' | 'ready' | 'blocked';
+        code?: string;
+    };
+    /** Logical deletion retains audit, Session and resource associations. */
+    deletedAt?: number;
+    executionControl?: KanbanBoardControl;
+    automation?: KanbanAutomationSettings;
+    number?: number;
+    id: string;
+    scope: {
+        kind: 'system';
+    } | {
+        kind: 'project';
+        projectId: string;
+    } | {
+        kind: 'collection';
+        namespace: string;
+        id: string;
+    };
+    title: string;
+    policy: KanbanPolicy;
+    agents?: Array<{
+        agentId: string;
+        responsibility: string;
+    }>;
+    members?: KanbanMember[];
+    workTypes?: KanbanWorkType[];
+    defaultWorkType?: string;
+    columns?: KanbanColumn[];
+    notifications?: KanbanNotificationPolicy;
+    revision: number;
+    items: KanbanItem[];
+    participants: KanbanParticipant[];
+}
+interface KanbanEvent {
+    sequence: number;
+    boardId: string;
+    itemId?: string;
+    operationId: string;
+    at: number;
+    kind: string;
+    actor: KanbanActor;
+    recipients: string[];
+    data: {
+        status?: KanbanItem['status'];
+        reference?: KanbanExternalReference;
+        code?: string;
+        itemTitle?: string;
+        dispatchId?: string;
+        readyItemIds?: string[];
+        planId?: string;
+        recordId?: string;
+        recordIds?: string[];
+        itemIds?: string[];
+        planning?: KanbanPlanning;
+        message?: string;
+        reason?: string;
+        resultRef?: string;
+        estimate?: KanbanEstimate;
+        workUnits?: number;
+    };
+}
+type KanbanCommand = KanbanTaskCommand | KanbanWorkflowCommand | {
+    type: 'delete-item';
+    itemId: string;
+} | {
+    type: 'request-record-cancellation';
+    recordId: string;
+} | {
+    type: 'cancel-record';
+    recordId: string;
+} | {
+    type: 'delete-record';
+    recordId: string;
+} | {
+    type: 'request-board-stop';
+    controlId: string;
+    intent: 'cancel' | 'delete';
+    mode: 'drain' | 'cancel';
+} | {
+    type: 'observe-board-stop';
+    controlId: string;
+    phase: 'waiting' | 'ready' | 'blocked';
+    code?: string;
+} | {
+    type: 'delete-board';
+} | {
+    type: 'set-board-control';
+    mode?: 'automatic' | 'manual';
+    paused?: boolean;
+} | {
+    type: 'edit-item';
+    itemId: string;
+    title: string;
+    responsibility: string;
+    acceptance: string;
+} | {
+    type: 'configure-automation';
+    settings: KanbanAutomationSettings;
+} | {
+    type: 'review-amendment';
+    itemId: string;
+    amendmentId: string;
+    accept: boolean;
+    reason?: string;
+} | {
+    type: 'append-record';
+    record: KanbanRecordInput;
+} | {
+    type: 'review-record';
+    recordId: string;
+    accept: boolean;
+} | {
+    type: 'link-record';
+    recordId: string;
+    itemId: string;
+} | {
+    type: 'create-item';
+    item: Pick<KanbanItem, 'id' | 'title' | 'responsibility' | 'acceptance' | 'eligibleAgentIds' | 'eligiblePrincipals' | 'externalRefs'>;
+    planning?: KanbanPlanning;
+    stage?: 'backlog' | 'open';
+    launch?: {
+        mode?: 'automatic' | 'manual';
+        paused?: boolean;
+    };
+} | {
+    type: 'register-session';
+    itemId?: string;
+    sessionId: string;
+    agentId?: string;
+    role: KanbanParticipant['roles'][number];
+    subscribed: boolean;
+} | {
+    type: 'claim';
+    itemId: string;
+    estimate?: KanbanEstimate;
+} | {
+    type: 'renew';
+    itemId: string;
+    token: string;
+} | {
+    type: 'progress';
+    itemId: string;
+    token: string;
+    workUnits: number;
+    estimate?: KanbanEstimate;
+} | {
+    type: 'request-transfer';
+    itemId: string;
+    token: string;
+    agentId?: string;
+    target?: KanbanPrincipal;
+} | {
+    type: 'accept-transfer';
+    itemId: string;
+    estimate?: KanbanEstimate;
+} | {
+    type: 'submit';
+    itemId: string;
+    token: string;
+    resultRef: string;
+} | {
+    type: 'review';
+    itemId: string;
+    accept: boolean;
+} | {
+    type: 'message';
+    itemId?: string;
+    message: string;
+    recipientSessionIds: string[];
+} | {
+    type: 'scan';
+} | {
+    type: 'apply-discovery';
+    batch: KanbanDiscoveryBatch;
+} | {
+    type: 'publish-proposal';
+    itemId: string;
+    stage?: 'backlog' | 'open';
+} | {
+    type: 'plan-item';
+    itemId: string;
+    planning: KanbanPlanning;
+} | {
+    type: 'set-stage';
+    itemId: string;
+    stage: 'backlog' | 'open';
+} | {
+    type: 'cancel-item';
+    itemId: string;
+    reason: string;
+} | {
+    type: 'close-plan';
+    itemId: string;
+    resultRef: string;
+} | {
+    type: 'archive-items';
+    itemIds: string[];
+    reason: string;
+} | {
+    type: 'restore-item';
+    itemId: string;
+} | {
+    type: 'release-item';
+    itemId: string;
+    token: string;
+    next: 'backlog' | 'cancelled';
+    reason: string;
+} | {
+    type: 'link-reference';
+    itemId: string;
+    reference: KanbanExternalReference;
+} | {
+    type: 'block-item';
+    itemId: string;
+    reason: string;
+    token?: string;
+} | {
+    type: 'unblock-item';
+    itemId: string;
+    token?: string;
+};
+interface KanbanRequest {
+    operationId: string;
+    expectedRevision: number;
+    command: KanbanCommand;
+}
+/** Board directory metadata with item labels; coordination bodies require read()/item(). */
+type KanbanBoardSummary = Omit<KanbanBoard, 'items'> & {
+    executionPhase?: ReturnType<typeof boardControlPhase>;
+    items: Array<Pick<KanbanItem, 'id' | 'title' | 'number'>>;
+};
+interface KanbanService {
+    workflow(boardId: string): Promise<KanbanWorkflowState>;
+    resolve(reference: string): Promise<KanbanReferenceTarget>;
+    suggest(boardId: string, query: KanbanSuggestionQuery): Promise<KanbanSuggestionPage>;
+    records(boardId: string, query?: KanbanRecordQuery): Promise<KanbanRecordPage>;
+    record(boardId: string, recordId: string): Promise<KanbanProjectRecord>;
+    currentPrincipal(): Promise<KanbanPrincipal>;
+    create(board: KanbanBoardInput): Promise<KanbanBoard>;
+    /** Full coordination snapshot; user-facing lists should use query(). */
+    read(boardId: string): Promise<KanbanBoard>;
+    list(): Promise<KanbanBoard[]>;
+    catalog(): Promise<KanbanBoardSummary[]>;
+    execute(boardId: string, request: KanbanRequest): Promise<KanbanBoard>;
+    events(boardId: string, afterSequence?: number, limit?: number): Promise<KanbanEvent[]>;
+    related(sessionId: string): Promise<KanbanBoard[]>;
+    query(boardId: string, query?: KanbanItemQuery): Promise<KanbanItemPage>;
+    item(boardId: string, itemId: string): Promise<{
+        item: KanbanItem;
+        task?: KanbanTaskProjection;
+        archive?: Omit<KanbanArchivedItem, 'item'>;
+    }>;
+    overview(boardId: string): Promise<KanbanOverview>;
+    scan(): Promise<void>;
+}
+type KanbanBoardInput = Pick<KanbanBoard, 'id' | 'scope' | 'title' | 'agents' | 'members' | 'workTypes' | 'defaultWorkType' | 'columns' | 'notifications'> & {
+    policy?: Partial<KanbanPolicy>;
+};
+
+interface KanbanPrincipal {
+    kind: 'agent' | 'human' | 'service';
+    id: string;
+}
+interface KanbanMember extends KanbanPrincipal {
+    responsibility: string;
+    roles?: Array<'worker' | 'reviewer' | 'coordinator'>;
+}
+interface KanbanWorkType {
+    id: string;
+    label: string;
+    rank: number;
+    executable: boolean;
+}
+interface KanbanColumn {
+    id: string;
+    label: string;
+    states: KanbanItem['status'][];
+}
+interface KanbanNotificationPolicy {
+    rules?: Record<string, 'info' | 'error' | 'none'>;
+}
+declare const DEFAULT_KANBAN_WORK_TYPES: readonly KanbanWorkType[];
+interface KanbanExternalReference {
+    system: string;
+    id: string;
+    revision?: string;
+}
+/** A composite work item delegates execution to its children. */
+declare function executableWorkItem(board: Pick<KanbanBoard, 'workTypes' | 'defaultWorkType'>, item: {
+    planning?: {
+        kind: string;
+        execution?: 'direct' | 'children';
+    };
+}): boolean;
+
+interface KanbanAutomationSettings {
+    preparation?: KanbanExternalReference;
+    preparationOptions?: Record<string, string>;
+    enabled: boolean;
+    planner: KanbanExternalReference;
+    executor: KanbanExternalReference;
+    coordinator: KanbanPrincipal;
+    worker: KanbanPrincipal;
+    autoAccept: boolean;
+}
+interface KanbanAutomationOption {
+    name: string;
+    label: string;
+    defaultValue?: string;
+    choices?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+interface KanbanAutomationTarget {
+    reference: KanbanExternalReference;
+    label: string;
+    options?: KanbanAutomationOption[];
+}
+interface KanbanAutomationCatalog {
+    preparations?: KanbanAutomationTarget[];
+    targets: KanbanAutomationTarget[];
+    coordinator: KanbanPrincipal;
+    worker: KanbanPrincipal;
+}
+interface KanbanAnalysisStatus {
+    itemId: string;
+    state: 'analyzing' | 'ready' | 'clarification' | 'failed' | 'unknown';
+    reason?: string;
+    code?: string;
+    dependencies?: string[];
+}
+declare function sameAutomationBinding(left?: KanbanAutomationSettings, right?: KanbanAutomationSettings): boolean;
+
+interface KanbanPlanning {
+    kind: string;
+    execution?: 'direct' | 'children';
+    dueAt?: number;
+    parentId?: string;
+    area?: string;
+    milestone?: string;
+    priority: number;
+    dependencies: string[];
+    references: string[];
+}
+interface KanbanItemSummary {
+    deletedAt?: number;
+    launch?: KanbanLaunch;
+    analysis?: KanbanAnalysisStatus;
+    control?: KanbanTaskControl;
+    issues?: KanbanTaskIssue[];
+    blocked?: KanbanItem['blocked'];
+    task?: KanbanTaskProjection;
+    number?: number;
+    discoveryFingerprint?: string;
+    pendingAmendments?: number;
+    id: string;
+    title: string;
+    status: KanbanItem['status'];
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    externalRefs?: KanbanExternalReference[];
+    planning: KanbanPlanning;
+    sessionIds: string[];
+    closedAt?: number;
+    archivedAt?: number;
+    archiveReason?: string;
+    progress?: {
+        total: number;
+        completed: number;
+        cancelled: number;
+        inProgress: number;
+    };
+}
+interface KanbanArchivedItem {
+    item: KanbanItem;
+    archivedAt: number;
+    reason: string;
+}
+interface KanbanItemQuery {
+    includeDeleted?: boolean;
+    phase?: KanbanTaskPhase;
+    view?: 'ready' | 'backlog' | 'in-progress' | 'review' | 'closed' | 'proposed' | 'archive' | 'all';
+    area?: string;
+    milestone?: string;
+    parentId?: string;
+    kind?: KanbanPlanning['kind'];
+    reference?: Pick<KanbanExternalReference, 'system' | 'id'>;
+    sessionId?: string;
+    search?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface KanbanItemPage {
+    revision: number;
+    total: number;
+    items: KanbanItemSummary[];
+    nextCursor?: string;
+}
+interface KanbanOverview {
+    revision: number;
+    visible: number;
+    active: number;
+    archived: number;
+    ready: number;
+    inProgress: number;
+    backlog: number;
+    proposed: number;
+    closed: number;
+    dueForReview: number;
+    limits: {
+        ready: number;
+        inProgress: number;
+        perAgent: number;
+        perAssignee: number;
+    };
+}
+
+export { type KanbanTaskIssue as $, type KanbanLaunch as A, type KanbanMember as B, type KanbanNotificationPolicy as C, DEFAULT_KANBAN_WORK_TYPES as D, type KanbanOverview as E, type KanbanParticipant as F, type KanbanPlanning as G, type KanbanPolicy as H, type KanbanPrincipal as I, type KanbanProjectRecord as J, type KanbanActor as K, type KanbanPublishedPlan as L, type KanbanRecordActivity as M, type KanbanRecordInput as N, type KanbanRecordPage as O, type KanbanRecordQuery as P, type KanbanRecordSummary as Q, type KanbanReferenceTarget as R, type KanbanRequest as S, type KanbanService as T, type KanbanSourceRef as U, type KanbanSuggestion as V, type KanbanSuggestionKind as W, type KanbanSuggestionPage as X, type KanbanSuggestionQuery as Y, type KanbanTaskCommand as Z, type KanbanTaskControl as _, type KanbanAmendment as a, type KanbanTaskPhase as a0, type KanbanTaskProjection as a1, type KanbanText as a2, type KanbanWorkDefinition as a3, type KanbanWorkPlan as a4, type KanbanWorkType as a5, type KanbanWorkflowCommand as a6, type KanbanWorkflowState as a7, boardAllowsStart as a8, boardControlPhase as a9, executableWorkItem as aa, kanbanReference as ab, sameAutomationBinding as ac, type KanbanAnalysisStatus as b, type KanbanArchivedItem as c, type KanbanArtifactRef as d, type KanbanAssignment as e, type KanbanAutomationCatalog as f, type KanbanAutomationOption as g, type KanbanAutomationSettings as h, type KanbanAutomationTarget as i, type KanbanBoard as j, type KanbanBoardControl as k, type KanbanBoardInput as l, type KanbanBoardSummary as m, type KanbanColumn as n, type KanbanCommand as o, type KanbanDiscoveryBatch as p, type KanbanDiscoveryChange as q, type KanbanDispatch as r, type KanbanEstimate as s, type KanbanEvent as t, type KanbanExternalReference as u, type KanbanFixSession as v, type KanbanItem as w, type KanbanItemPage as x, type KanbanItemQuery as y, type KanbanItemSummary as z };