@andypai/agent-kanban 0.2.0 → 0.3.1

package/src/providers/linear.ts

@@ -1,39 +1,62 @@
 import type { Database } from 'bun:sqlite'
-import { ErrorCode, KanbanError } from '../errors.ts'
+import { ErrorCode, KanbanError } from '../errors'
 import type {
   ActivityEntry,
   BoardBootstrap,
   BoardConfig,
   BoardMetrics,
   Column,
+  TaskComment,
   Task,
-} from '../types.ts'
-import { LINEAR_CAPABILITIES } from './capabilities.ts'
+} from '../types'
+import { headerLower, verifyHmacSha256, type WebhookRequest, type WebhookResult } from '../webhooks'
+import { LINEAR_CAPABILITIES } from './capabilities'
 import {
+  adjustLinearIssueCommentCount,
+  deleteLinearIssue,
   getCachedBoard,
   getCachedColumns,
   getCachedConfig,
+  getCachedLinearActivity,
   getCachedTask,
   getCachedTasks,
   initLinearCacheSchema,
   loadSyncMeta,
+  pruneLinearIssues,
   replaceStates,
+  saveLinearActivity,
   saveSyncMeta,
   upsertIssues,
   upsertProjects,
   upsertUsers,
-} from './linear-cache.ts'
-import { LinearClient } from './linear-client.ts'
-import { unsupportedOperation } from './errors.ts'
+  type LinearActivityRow,
+} from './linear-cache'
+import { LinearClient, type LinearComment } from './linear-client'
+import { unsupportedOperation } from './errors'
 import type {
   CreateTaskInput,
   KanbanProvider,
   ProviderContext,
+  ProviderSyncStatus,
   TaskListFilters,
   UpdateTaskInput,
-} from './types.ts'
+} from './types'
 
 const SYNC_INTERVAL_MS = 30_000
+const FULL_RECONCILIATION_INTERVAL_MS = 5 * 60_000
+
+function parseTimestamp(value: string | null | undefined): number {
+  if (!value) return 0
+  const parsed = Date.parse(value)
+  return Number.isFinite(parsed) ? parsed : 0
+}
+
+function maxTimestamp(a: string | null | undefined, b: string | null | undefined): string | null {
+  const aMs = parseTimestamp(a)
+  const bMs = parseTimestamp(b)
+  if (!aMs && !bMs) return null
+  return aMs >= bMs ? (a ?? null) : (b ?? null)
+}
 
 function toLinearPriority(priority: Task['priority'] | undefined): number | undefined {
   switch (priority) {
@@ -63,18 +86,40 @@ export class LinearProvider implements KanbanProvider {
     this.client = new LinearClient(apiKey)
   }
 
+  private resolvedTeamId(): string {
+    return loadSyncMeta(this.db).team?.id ?? this.teamId
+  }
+
+  private async getConfiguredTeam(): Promise<{ id: string; key: string; name: string }> {
+    const metaTeam = loadSyncMeta(this.db).team
+    if (metaTeam) return metaTeam
+
+    const team = await this.client.getTeam(this.teamId)
+    const configuredTeam = { id: team.id, key: team.key, name: team.name }
+    saveSyncMeta(this.db, { team: configuredTeam })
+    return configuredTeam
+  }
+
   private async sync(force = false): Promise<void> {
     const meta = loadSyncMeta(this.db)
-    const lastSyncAtMs = meta.lastSyncAt ? Date.parse(meta.lastSyncAt) : 0
-    if (!force && lastSyncAtMs && Date.now() - lastSyncAtMs < SYNC_INTERVAL_MS) return
+    const lastSyncAtMs = parseTimestamp(meta.lastSyncAt)
+    const lastFullSyncAtMs = parseTimestamp(meta.lastFullSyncAt)
+    const now = Date.now()
+    if (!force && lastSyncAtMs && now - lastSyncAtMs < SYNC_INTERVAL_MS) return
+
+    const shouldFullSync =
+      force ||
+      !lastFullSyncAtMs ||
+      !meta.lastIssueUpdatedAt ||
+      now - lastFullSyncAtMs >= FULL_RECONCILIATION_INTERVAL_MS
 
-    const [team, users, projects, issues] = await Promise.all([
-      this.client.getTeam(this.teamId),
+    const team = await this.client.getTeam(this.teamId)
+    const [users, projects, issues] = await Promise.all([
       this.client.listUsers(),
       this.client.listProjects(),
       this.client.listIssues(
-        this.teamId,
-        force ? undefined : (meta.lastIssueUpdatedAt ?? undefined),
+        team.id,
+        shouldFullSync ? undefined : (meta.lastIssueUpdatedAt ?? undefined),
       ),
     ])
 
@@ -96,27 +141,93 @@ export class LinearProvider implements KanbanProvider {
         stateId: issue.state.id,
         stateName: issue.state.name,
         statePosition: issue.state.position,
+        labels: issue.labels ?? [],
+        commentCount: issue.commentCount,
         url: issue.url ?? null,
         createdAt: issue.createdAt,
         updatedAt: issue.updatedAt,
       })),
     )
+    if (shouldFullSync) {
+      pruneLinearIssues(
+        this.db,
+        issues.map((issue) => issue.id),
+      )
+    }
 
-    const newestIssueTimestamp =
+    const newestIssueTimestamp = maxTimestamp(
+      meta.lastIssueUpdatedAt,
       issues.length > 0
         ? issues.reduce(
             (latest, issue) => (issue.updatedAt > latest ? issue.updatedAt : latest),
             issues[0]!.updatedAt,
           )
-        : meta.lastIssueUpdatedAt
+        : null,
+    )
+
+    // Best-effort changelog ingest; failures don't fail the main sync.
+    await this.ingestTeamHistory(
+      issues.map((issue) => issue.id),
+      meta.lastIssueUpdatedAt,
+    ).catch((err) => {
+      console.warn('[linear] issueHistory ingest failed:', err)
+    })
 
+    const syncedAt = new Date().toISOString()
     saveSyncMeta(this.db, {
       team: { id: team.id, key: team.key, name: team.name },
-      lastSyncAt: new Date().toISOString(),
-      lastIssueUpdatedAt: newestIssueTimestamp ?? new Date().toISOString(),
+      lastSyncAt: syncedAt,
+      lastFullSyncAt: shouldFullSync ? syncedAt : undefined,
+      lastIssueUpdatedAt: newestIssueTimestamp ?? syncedAt,
     })
   }
 
+  private async ingestTeamHistory(issueIds: string[], sinceIso: string | null): Promise<void> {
+    if (issueIds.length === 0) return
+    const concurrency = 5
+    for (let i = 0; i < issueIds.length; i += concurrency) {
+      const batch = issueIds.slice(i, i + concurrency)
+      const results = await Promise.all(
+        batch.map((issueId) => this.fetchIssueHistory(issueId, sinceIso)),
+      )
+      const rows = results.flat()
+      if (rows.length > 0) saveLinearActivity(this.db, rows)
+    }
+  }
+
+  private async fetchIssueHistory(
+    issueId: string,
+    sinceIso: string | null,
+  ): Promise<LinearActivityRow[]> {
+    const rows: LinearActivityRow[] = []
+    let cursor: string | null = null
+    for (let page = 0; page < 10; page++) {
+      const batch = await this.client.listIssueHistory({ issueId, first: 50, after: cursor })
+      let reachedKnown = false
+      for (const node of batch.nodes) {
+        // Linear returns history newest-first; once we hit an entry we've already ingested,
+        // every subsequent page is older still, so break out of pagination entirely.
+        if (sinceIso && node.createdAt <= sinceIso) {
+          reachedKnown = true
+          break
+        }
+        if (!node.fromState && !node.toState) continue
+        rows.push({
+          issue_id: issueId,
+          history_id: node.id,
+          item_field: 'state',
+          from_value: node.fromState?.id ?? null,
+          to_value: node.toState?.id ?? null,
+          created_at: node.createdAt,
+        })
+      }
+      if (reachedKnown) break
+      if (!batch.pageInfo.hasNextPage || !batch.pageInfo.endCursor) break
+      cursor = batch.pageInfo.endCursor
+    }
+    return rows
+  }
+
   private resolveTask(idOrRef: string): Task {
     const task = getCachedTask(this.db, idOrRef)
     if (!task) {
@@ -155,6 +266,30 @@ export class LinearProvider implements KanbanProvider {
     return row?.id
   }
 
+  private toTaskComment(task: Task, comment: LinearComment): TaskComment {
+    return {
+      id: comment.id,
+      task_id: task.id,
+      body: comment.body,
+      author: comment.user?.displayName || comment.user?.name || null,
+      created_at: comment.createdAt,
+      updated_at: comment.updatedAt,
+    }
+  }
+
+  async syncCache(): Promise<void> {
+    await this.sync()
+  }
+
+  async getSyncStatus(): Promise<ProviderSyncStatus> {
+    const meta = loadSyncMeta(this.db)
+    return {
+      lastSyncAt: meta.lastSyncAt,
+      lastFullSyncAt: meta.lastFullSyncAt,
+      lastWebhookAt: meta.lastWebhookAt,
+    }
+  }
+
   async getContext(): Promise<ProviderContext> {
     await this.sync()
     const meta = loadSyncMeta(this.db)
@@ -214,7 +349,7 @@ export class LinearProvider implements KanbanProvider {
     await this.sync()
     const state = input.column ? this.resolveState(input.column) : undefined
     const result = await this.client.createIssue({
-      teamId: this.teamId,
+      teamId: this.resolvedTeamId(),
       stateId: state?.id,
       title: input.title,
       description: input.description,
@@ -240,6 +375,8 @@ export class LinearProvider implements KanbanProvider {
         stateId: issue.state.id,
         stateName: issue.state.name,
         statePosition: issue.state.position,
+        labels: issue.labels ?? [],
+        commentCount: issue.commentCount,
         url: issue.url ?? null,
         createdAt: issue.createdAt,
         updatedAt: issue.updatedAt,
@@ -251,6 +388,12 @@ export class LinearProvider implements KanbanProvider {
   async updateTask(idOrRef: string, input: UpdateTaskInput) {
     await this.sync()
     const task = this.resolveTask(idOrRef)
+    if (input.expectedVersion !== undefined && task.version !== input.expectedVersion) {
+      throw new KanbanError(
+        ErrorCode.CONFLICT,
+        `Linear issue ${task.externalRef ?? idOrRef} was updated remotely (expected version ${input.expectedVersion}, current ${task.version ?? 'unknown'})`,
+      )
+    }
     const updateInput: Record<string, unknown> = {}
     if (input.title !== undefined) updateInput['title'] = input.title
     if (input.description !== undefined) updateInput['description'] = input.description
@@ -286,8 +429,75 @@ export class LinearProvider implements KanbanProvider {
     unsupportedOperation('Task deletion is not supported in Linear mode')
   }
 
-  async getActivity(_limit?: number, _taskId?: string): Promise<ActivityEntry[]> {
-    unsupportedOperation('Activity is not available in Linear mode')
+  async listComments(idOrRef: string): Promise<TaskComment[]> {
+    await this.sync()
+    const task = this.resolveTask(idOrRef)
+    const comments = await this.client.listComments(task.providerId || task.id)
+    return comments.map((comment) => this.toTaskComment(task, comment))
+  }
+
+  async getComment(idOrRef: string, commentId: string): Promise<TaskComment> {
+    await this.sync()
+    const task = this.resolveTask(idOrRef)
+    const comment = await this.client.getComment(commentId)
+    return this.toTaskComment(task, comment)
+  }
+
+  async comment(idOrRef: string, body: string): Promise<TaskComment> {
+    await this.sync()
+    const task = this.resolveTask(idOrRef)
+    const result = await this.client.commentCreate(task.providerId || task.id, body)
+    if (!result.success || !result.comment) {
+      throw new KanbanError(ErrorCode.PROVIDER_UPSTREAM_ERROR, 'Linear comment creation failed')
+    }
+    adjustLinearIssueCommentCount(this.db, task.providerId || task.id, 1)
+    return this.toTaskComment(task, result.comment)
+  }
+
+  async updateComment(idOrRef: string, commentId: string, body: string): Promise<TaskComment> {
+    await this.sync()
+    const task = this.resolveTask(idOrRef)
+    const result = await this.client.commentUpdate(commentId, body)
+    if (!result.success || !result.comment) {
+      throw new KanbanError(ErrorCode.PROVIDER_UPSTREAM_ERROR, 'Linear comment update failed')
+    }
+    return this.toTaskComment(task, result.comment)
+  }
+
+  async getActivity(limit?: number, taskId?: string): Promise<ActivityEntry[]> {
+    await this.sync()
+    const issueId = taskId ? this.resolveIssueIdFromTaskId(taskId) : undefined
+    const rows = getCachedLinearActivity(this.db, {
+      ...(issueId !== undefined ? { issueId } : {}),
+      limit: limit ?? 100,
+    })
+    return rows.map((row) => this.activityRowToEntry(row))
+  }
+
+  private resolveIssueIdFromTaskId(taskId: string): string | undefined {
+    const normalized = taskId.startsWith('linear:') ? taskId.slice('linear:'.length) : taskId
+    const row = this.db
+      .query<
+        { id: string },
+        Record<string, string>
+      >(`SELECT id FROM linear_issues WHERE id = $lookup OR identifier = $lookup LIMIT 1`)
+      .get({ $lookup: normalized })
+    return row?.id
+  }
+
+  private activityRowToEntry(row: LinearActivityRow): ActivityEntry {
+    // fromState/toState already reference state ids which agent-kanban
+    // surfaces 1:1 as column ids (see linear_states/getCachedColumns),
+    // so no lookup is needed here.
+    return {
+      id: `linear-activity:${row.issue_id}:${row.history_id}:${row.item_field}`,
+      task_id: `linear:${row.issue_id}`,
+      action: row.item_field === 'state' ? 'moved' : 'updated',
+      field_changed: row.item_field,
+      old_value: row.from_value,
+      new_value: row.to_value,
+      timestamp: row.created_at,
+    }
   }
 
   async getMetrics(): Promise<BoardMetrics> {
@@ -302,4 +512,112 @@ export class LinearProvider implements KanbanProvider {
   async patchConfig(_input: Partial<BoardConfig>): Promise<BoardConfig> {
     unsupportedOperation('Config mutation is not supported in Linear mode')
   }
+
+  async handleWebhook(payload: WebhookRequest): Promise<WebhookResult> {
+    const secret = process.env['LINEAR_WEBHOOK_SECRET']
+    if (secret) {
+      const sig = headerLower(payload.headers, 'linear-signature')
+      if (!verifyHmacSha256(secret, payload.rawBody, sig)) {
+        return { handled: false, unauthorized: true, message: 'Invalid signature' }
+      }
+    }
+    let body: {
+      action?: 'create' | 'update' | 'remove'
+      type?: string
+      data?: {
+        id: string
+        identifier?: string
+        title?: string
+        description?: string | null
+        priority?: number | null
+        url?: string | null
+        createdAt?: string
+        updatedAt?: string
+        assignee?: { id: string; name?: string | null } | null
+        assigneeId?: string | null
+        project?: { id: string; name: string } | null
+        projectId?: string | null
+        state?: { id: string; name: string; position?: number } | null
+        stateId?: string | null
+        team?: { id?: string | null; key?: string | null } | null
+        teamId?: string | null
+        labels?: Array<{ id: string; name: string }> | null
+        commentCount?: number | null
+      }
+    } = {}
+    try {
+      body = JSON.parse(payload.rawBody) as typeof body
+    } catch {
+      return { handled: false, message: 'Invalid JSON body' }
+    }
+    if (body.type !== 'Issue') {
+      return { handled: false, message: `Ignoring ${body.type ?? 'unknown'} event` }
+    }
+    const data = body.data
+    if (!data) return { handled: false, message: 'No data in payload' }
+
+    if (body.action === 'remove') {
+      deleteLinearIssue(this.db, data.id)
+      saveSyncMeta(this.db, { lastWebhookAt: new Date().toISOString() })
+      return { handled: true }
+    }
+
+    if (body.action === 'create' || body.action === 'update') {
+      const configuredTeam = await this.getConfiguredTeam()
+      const payloadTeamId = data.team?.id ?? data.teamId ?? null
+      if (payloadTeamId && payloadTeamId !== configuredTeam.id) {
+        return {
+          handled: false,
+          message: `Ignoring issue from team '${payloadTeamId}'`,
+        }
+      }
+
+      if (!payloadTeamId) {
+        const issueTeam = await this.client.getIssueTeam(data.id)
+        if (!issueTeam) {
+          return {
+            handled: false,
+            message: `Ignoring issue '${data.id}' because its team could not be verified`,
+          }
+        }
+        if (issueTeam.id !== configuredTeam.id) {
+          return {
+            handled: false,
+            message: `Ignoring issue from team '${issueTeam.key}'`,
+          }
+        }
+      }
+
+      if (!data.identifier || !data.title || !data.createdAt || !data.updatedAt) {
+        return { handled: false, message: 'Missing required issue fields' }
+      }
+      const stateId = data.state?.id ?? data.stateId ?? null
+      if (!stateId) return { handled: false, message: 'Missing state id' }
+      upsertIssues(this.db, [
+        {
+          id: data.id,
+          identifier: data.identifier,
+          title: data.title,
+          description: data.description ?? '',
+          priority: data.priority ?? 0,
+          assigneeId: data.assignee?.id ?? data.assigneeId ?? null,
+          assigneeName: data.assignee?.name ?? null,
+          projectId: data.project?.id ?? data.projectId ?? null,
+          projectName: data.project?.name ?? null,
+          stateId,
+          stateName: data.state?.name ?? '',
+          statePosition: data.state?.position ?? 0,
+          labels: (data.labels ?? []).map((l) => l.name),
+          commentCount: data.commentCount,
+          url: data.url ?? null,
+          createdAt: data.createdAt,
+          updatedAt: data.updatedAt,
+        },
+      ])
+      saveSyncMeta(this.db, { lastWebhookAt: new Date().toISOString() })
+      return { handled: true }
+    }
+
+    return { handled: false, message: `Unsupported action: ${body.action}` }
+  }
 }

package/src/providers/local.ts

@@ -1,27 +1,35 @@
 import type { Database } from 'bun:sqlite'
-import { listActivity } from '../activity.ts'
-import { getConfigPath, loadConfig, saveConfig } from '../config.ts'
+import { listActivity } from '../activity'
+import { getConfigPath, loadConfig, saveConfig } from '../config'
 import {
+  addComment,
+  countComments,
+  countCommentsByTask,
   addTask,
   deleteTask,
   getBoardView,
+  getComment as getTaskComment,
   getDbPath,
   getTask,
+  listComments as listTaskComments,
   listColumns,
   listTasks,
   moveTask,
+  updateComment as updateTaskComment,
   updateTask,
-} from '../db.ts'
-import { getBoardMetrics, getDiscoveredAssignees, getDiscoveredProjects } from '../metrics.ts'
-import type { BoardBootstrap, BoardConfig, Task } from '../types.ts'
-import { LOCAL_CAPABILITIES } from './capabilities.ts'
+} from '../db'
+import { getBoardMetrics, getDiscoveredAssignees, getDiscoveredProjects } from '../metrics'
+import type { BoardBootstrap, BoardConfig, Task, TaskComment } from '../types'
+import { ErrorCode, KanbanError } from '../errors'
+import { LOCAL_CAPABILITIES } from './capabilities'
 import type {
   CreateTaskInput,
   KanbanProvider,
   ProviderContext,
+  ProviderSyncStatus,
   TaskListFilters,
   UpdateTaskInput,
-} from './types.ts'
+} from './types'
 
 function buildLocalConfig(
   db: Database,
@@ -37,15 +45,6 @@ function buildLocalConfig(
   }
 }
 
-function enrichTask(task: Task): Task {
-  return {
-    ...task,
-    providerId: task.id,
-    externalRef: task.id,
-    url: null,
-  }
-}
-
 export class LocalProvider implements KanbanProvider {
   readonly type = 'local' as const
 
@@ -54,6 +53,22 @@ export class LocalProvider implements KanbanProvider {
     private readonly dbPath = getDbPath(),
   ) {}
 
+  private enrichTask(task: Task, commentCount?: number): Task {
+    const revision = task.revision ?? 0
+    const assignees = task.assignee ? [task.assignee] : []
+    return {
+      ...task,
+      providerId: task.id,
+      externalRef: task.id,
+      url: null,
+      assignees,
+      labels: [],
+      comment_count: commentCount ?? countComments(this.db, task.id),
+      version: String(revision),
+      source_updated_at: null,
+    }
+  }
+
   async getContext(): Promise<ProviderContext> {
     return {
       provider: this.type,
@@ -77,10 +92,11 @@ export class LocalProvider implements KanbanProvider {
 
   async getBoard() {
     const board = getBoardView(this.db)
+    const counts = countCommentsByTask(this.db)
     return {
       columns: board.columns.map((column) => ({
         ...column,
-        tasks: column.tasks.map(enrichTask),
+        tasks: column.tasks.map((task) => this.enrichTask(task, counts.get(task.id) ?? 0)),
       })),
     }
   }
@@ -90,27 +106,58 @@ export class LocalProvider implements KanbanProvider {
   }
 
   async listTasks(filters: TaskListFilters = {}) {
-    return listTasks(this.db, filters).map(enrichTask)
+    const counts = countCommentsByTask(this.db)
+    return listTasks(this.db, filters).map((task) =>
+      this.enrichTask(task, counts.get(task.id) ?? 0),
+    )
   }
 
   async getTask(idOrRef: string) {
-    return enrichTask(getTask(this.db, idOrRef))
+    return this.enrichTask(getTask(this.db, idOrRef))
   }
 
   async createTask(input: CreateTaskInput) {
-    return enrichTask(addTask(this.db, input.title, input))
+    return this.enrichTask(addTask(this.db, input.title, input))
   }
 
   async updateTask(idOrRef: string, input: UpdateTaskInput) {
-    return enrichTask(updateTask(this.db, idOrRef, input))
+    if (input.expectedVersion !== undefined) {
+      const current = getTask(this.db, idOrRef)
+      const currentVersion = String(current.revision ?? 0)
+      if (currentVersion !== input.expectedVersion) {
+        throw new KanbanError(
+          ErrorCode.CONFLICT,
+          `Task ${idOrRef} was modified since you loaded it (expected version ${input.expectedVersion}, current ${currentVersion})`,
+        )
+      }
+    }
+    const updates: Omit<UpdateTaskInput, 'expectedVersion'> = { ...input }
+    delete (updates as UpdateTaskInput).expectedVersion
+    return this.enrichTask(updateTask(this.db, idOrRef, updates))
   }
 
   async moveTask(idOrRef: string, column: string) {
-    return enrichTask(moveTask(this.db, idOrRef, column))
+    return this.enrichTask(moveTask(this.db, idOrRef, column))
   }
 
   async deleteTask(idOrRef: string) {
-    return enrichTask(deleteTask(this.db, idOrRef))
+    return this.enrichTask(deleteTask(this.db, idOrRef))
+  }
+
+  async listComments(idOrRef: string): Promise<TaskComment[]> {
+    return listTaskComments(this.db, idOrRef)
+  }
+
+  async getComment(idOrRef: string, commentId: string): Promise<TaskComment> {
+    return getTaskComment(this.db, idOrRef, commentId)
+  }
+
+  async comment(idOrRef: string, body: string): Promise<TaskComment> {
+    return addComment(this.db, idOrRef, body)
+  }
+
+  async updateComment(idOrRef: string, commentId: string, body: string): Promise<TaskComment> {
+    return updateTaskComment(this.db, idOrRef, commentId, body)
   }
 
   async getActivity(limit?: number, taskId?: string) {
@@ -132,4 +179,8 @@ export class LocalProvider implements KanbanProvider {
     saveConfig(getConfigPath(this.dbPath), config)
     return this.getConfig()
   }
+
+  async getSyncStatus(): Promise<ProviderSyncStatus | null> {
+    return null
+  }
 }

package/src/providers/types.ts

@@ -1,3 +1,4 @@
+import type { WebhookRequest, WebhookResult } from '../webhooks'
 import type {
   ActivityEntry,
   BoardBootstrap,
@@ -8,8 +9,9 @@ import type {
   Priority,
   ProviderCapabilities,
   ProviderTeamInfo,
+  TaskComment,
   Task,
-} from '../types.ts'
+} from '../types'
 
 export interface TaskListFilters {
   column?: string
@@ -37,16 +39,23 @@ export interface UpdateTaskInput {
   assignee?: string
   project?: string
   metadata?: string
+  expectedVersion?: string
 }
 
 export interface ProviderContext {
-  provider: 'local' | 'linear'
+  provider: 'local' | 'linear' | 'jira'
   capabilities: ProviderCapabilities
   team: ProviderTeamInfo | null
 }
 
+export interface ProviderSyncStatus {
+  lastSyncAt: string | null
+  lastFullSyncAt: string | null
+  lastWebhookAt: string | null
+}
+
 export interface KanbanProvider {
-  readonly type: 'local' | 'linear'
+  readonly type: 'local' | 'linear' | 'jira'
 
   getContext(): Promise<ProviderContext>
   getBootstrap(): Promise<BoardBootstrap>
@@ -58,8 +67,15 @@ export interface KanbanProvider {
   updateTask(idOrRef: string, input: UpdateTaskInput): Promise<Task>
   moveTask(idOrRef: string, column: string): Promise<Task>
   deleteTask(idOrRef: string): Promise<Task>
+  listComments(idOrRef: string): Promise<TaskComment[]>
+  getComment(idOrRef: string, commentId: string): Promise<TaskComment>
+  comment(idOrRef: string, body: string): Promise<TaskComment>
+  updateComment(idOrRef: string, commentId: string, body: string): Promise<TaskComment>
   getActivity(limit?: number, taskId?: string): Promise<ActivityEntry[]>
   getMetrics(): Promise<BoardMetrics>
   getConfig(): Promise<BoardConfig>
   patchConfig(input: Partial<BoardConfig>): Promise<BoardConfig>
+  syncCache?(): Promise<void>
+  getSyncStatus?(): Promise<ProviderSyncStatus | null>
+  handleWebhook?(payload: WebhookRequest): Promise<WebhookResult>
 }