@andypai/agent-kanban 0.3.4 → 0.3.5

package/README.md

@@ -62,21 +62,26 @@ Running `kanban` with no arguments is equivalent to `kanban board view`.
 
 All operations route through a provider backend. Set `KANBAN_PROVIDER` to choose one.
 
-| Variable                  | Default       | Description                                                              |
-| ------------------------- | ------------- | ------------------------------------------------------------------------ |
-| `KANBAN_PROVIDER`         | `local`       | `local`, `linear`, or `jira`                                             |
-| `KANBAN_DB_PATH`          | auto-resolved | SQLite database path                                                     |
-| `KANBAN_SYNC_INTERVAL_MS` | `30000`       | Polling sync interval for remote providers; integer milliseconds >= 1000 |
-| `LINEAR_API_KEY`          | —             | Required when `KANBAN_PROVIDER=linear`                                   |
-| `LINEAR_TEAM_ID`          | —             | Required when `KANBAN_PROVIDER=linear`                                   |
-| `JIRA_BASE_URL`           | —             | Required when `KANBAN_PROVIDER=jira` (e.g. `https://acme.atlassian.net`) |
-| `JIRA_EMAIL`              | —             | Required when `KANBAN_PROVIDER=jira` (Atlassian account email)           |
-| `JIRA_API_TOKEN`          | —             | Required when `KANBAN_PROVIDER=jira` (Atlassian API token)               |
-| `JIRA_PROJECT_KEY`        | —             | Required when `KANBAN_PROVIDER=jira` (e.g. `ENG`)                        |
-| `JIRA_BOARD_ID`           | —             | Optional when `KANBAN_PROVIDER=jira` (Agile board id for column order)   |
-| `JIRA_ISSUE_TYPE`         | `Task`        | Optional when `KANBAN_PROVIDER=jira` (default issue type for new tasks)  |
-
-Without `KANBAN_DB_PATH`, the local provider resolves the database in this order:
+| Variable                     | Default       | Description                                                              |
+| ---------------------------- | ------------- | ------------------------------------------------------------------------ |
+| `KANBAN_PROVIDER`            | `local`       | `local`, `linear`, or `jira`                                             |
+| `KANBAN_STORAGE`             | `sqlite`      | `sqlite` or `postgres`                                                   |
+| `KANBAN_DATABASE_URL`        | —             | Required when `KANBAN_STORAGE=postgres`                                  |
+| `KANBAN_DB_PATH`             | auto-resolved | SQLite database path                                                     |
+| `KANBAN_DEFAULT_COLUMNS`     | —             | Optional bootstrap column names for local/Postgres caches                |
+| `KANBAN_DEFAULT_TASK_COLUMN` | —             | Optional created-task column override for local/Postgres caches          |
+| `KANBAN_SYNC_INTERVAL_MS`    | `30000`       | Polling sync interval for remote providers; integer milliseconds >= 1000 |
+| `LINEAR_API_KEY`             | —             | Required when `KANBAN_PROVIDER=linear`                                   |
+| `LINEAR_TEAM_ID`             | —             | Required when `KANBAN_PROVIDER=linear`                                   |
+| `JIRA_BASE_URL`              | —             | Required when `KANBAN_PROVIDER=jira` (e.g. `https://acme.atlassian.net`) |
+| `JIRA_EMAIL`                 | —             | Required when `KANBAN_PROVIDER=jira` (Atlassian account email)           |
+| `JIRA_API_TOKEN`             | —             | Required when `KANBAN_PROVIDER=jira` (Atlassian API token)               |
+| `JIRA_PROJECT_KEY`           | —             | Required when `KANBAN_PROVIDER=jira` (e.g. `ENG`)                        |
+| `JIRA_BOARD_ID`              | —             | Optional when `KANBAN_PROVIDER=jira` (Agile board id for column order)   |
+| `JIRA_ISSUE_TYPE`            | `Task`        | Optional when `KANBAN_PROVIDER=jira` (default issue type for new tasks)  |
+
+When `KANBAN_STORAGE=sqlite` and `KANBAN_DB_PATH` is unset, the local provider
+resolves the database in this order:
 
 1. `./.kanban/board.db` if it exists in the current working directory
 2. `~/.kanban/board.db` if it exists
@@ -246,6 +251,7 @@ Default columns: `recurring`, `backlog`, `in-progress`, `review`, `done`.
 ```bash
 kanban serve            # default port 3000
 kanban serve --port 8080
+kanban serve --sync-interval-ms 300000
 kanban serve --tunnel   # optional public URL for webhook testing
 ```
 
@@ -301,8 +307,9 @@ Starts a Bun HTTP server with:
 - **Readiness check** at `/api/ready` — reports whether the cache has warmed at least once
 - **Sync status** at `/api/sync-status` — reports background sync state plus provider sync metadata
 
-In `serve` mode, remote providers now warm once on startup and continue syncing
-in the background every `KANBAN_SYNC_INTERVAL_MS` milliseconds. Full
+In `serve` mode, remote providers warm once on startup and continue syncing in
+the background on the runtime's configured polling cadence. Use
+`KANBAN_SYNC_INTERVAL_MS` or `kanban serve --sync-interval-ms` to tune it. Full
 reconciliation is still handled by the provider-specific logic on top of that
 steady cadence.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andypai/agent-kanban",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Agent-friendly kanban board CLI. Manage tasks via bash commands, parse structured JSON output.",
   "homepage": "https://github.com/abpai/agent-kanban#readme",
   "repository": {
@@ -55,7 +55,8 @@
     "prepack": "cd ui && bun install --frozen-lockfile && bun run build"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "postgres": "^3.4.4"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",

package/src/__tests__/api.test.ts

@@ -3,17 +3,17 @@ import { Database } from 'bun:sqlite'
 import { initSchema, seedDefaultColumns, addTask } from '../db'
 import { handleRequest } from '../api'
 import { createProvider } from '../providers/index'
+import type { KanbanProvider } from '../providers/types'
 
 let db: Database
-let provider: ReturnType<typeof createProvider>
+let provider: KanbanProvider
 
 beforeEach(() => {
-  process.env['KANBAN_PROVIDER'] = 'local'
   db = new Database(':memory:')
   db.run('PRAGMA foreign_keys = ON')
   initSchema(db)
   seedDefaultColumns(db)
-  provider = createProvider(db, ':memory:')
+  provider = createProvider(db, { provider: 'local' }, ':memory:')
 })
 
 describe('handleRequest', () => {

package/src/__tests__/index.test.ts

@@ -59,8 +59,28 @@ describe('parseServeArgs', () => {
   })
 
   test('--tunnel opts in; --port and --db override', () => {
-    const opts = parseServeArgs(['serve', '--tunnel', '--port', '5050', '--db', '/tmp/b.db'])
-    expect(opts).toEqual({ db: '/tmp/b.db', port: 5050, tunnel: true })
+    const opts = parseServeArgs([
+      'serve',
+      '--tunnel',
+      '--port',
+      '5050',
+      '--db',
+      '/tmp/b.db',
+      '--sync-interval-ms',
+      '600000',
+    ])
+    expect(opts).toEqual({
+      db: '/tmp/b.db',
+      port: 5050,
+      syncIntervalMs: 600_000,
+      tunnel: true,
+    })
+  })
+
+  test('--sync-interval-ms rejects invalid values', () => {
+    for (const raw of ['999', '0']) {
+      expect(() => parseServeArgs(['serve', '--sync-interval-ms', raw])).toThrow(KanbanError)
+    }
   })
 })
 

package/src/__tests__/jira-wiring.test.ts

@@ -6,6 +6,7 @@ import { join } from 'node:path'
 import { ErrorCode, KanbanError } from '../errors'
 import { run } from '../index'
 import { createProvider } from '../providers/index'
+import { trackerConfigFromEnv } from '../tracker-config'
 
 const ENV_KEYS = [
   'KANBAN_PROVIDER',
@@ -17,6 +18,7 @@ const ENV_KEYS = [
   'JIRA_ISSUE_TYPE',
   'LINEAR_API_KEY',
   'LINEAR_TEAM_ID',
+  'KANBAN_SYNC_INTERVAL_MS',
 ] as const
 
 const tempRoot = mkdtempSync(join(tmpdir(), 'jira-wiring-'))
@@ -75,17 +77,16 @@ describe('jira-wiring', () => {
     }
   })
 
-  test('createProvider throws PROVIDER_NOT_CONFIGURED listing missing JIRA_API_TOKEN', () => {
-    const { db, dbPath } = makeDb()
+  test('trackerConfigFromEnv throws PROVIDER_NOT_CONFIGURED listing missing JIRA_API_TOKEN', () => {
     process.env['KANBAN_PROVIDER'] = 'jira'
     process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
     process.env['JIRA_EMAIL'] = 'a@example.com'
     delete process.env['JIRA_API_TOKEN']
     process.env['JIRA_PROJECT_KEY'] = 'ENG'
 
-    expect(() => createProvider(db, dbPath)).toThrow(KanbanError)
+    expect(() => trackerConfigFromEnv()).toThrow(KanbanError)
     try {
-      createProvider(db, dbPath)
+      trackerConfigFromEnv()
     } catch (err) {
       expect((err as KanbanError).code).toBe(ErrorCode.PROVIDER_NOT_CONFIGURED)
       expect((err as Error).message).toContain('JIRA_API_TOKEN')
@@ -93,8 +94,7 @@ describe('jira-wiring', () => {
     }
   })
 
-  test('createProvider throws PROVIDER_NOT_CONFIGURED listing multiple missing vars', () => {
-    const { db, dbPath } = makeDb()
+  test('trackerConfigFromEnv throws PROVIDER_NOT_CONFIGURED listing multiple missing vars', () => {
     process.env['KANBAN_PROVIDER'] = 'jira'
     process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
     delete process.env['JIRA_EMAIL']
@@ -104,7 +104,7 @@ describe('jira-wiring', () => {
     let msg = ''
     let code: string | undefined
     try {
-      createProvider(db, dbPath)
+      trackerConfigFromEnv()
     } catch (err) {
       msg = (err as Error).message
       code = (err as KanbanError).code
@@ -118,17 +118,42 @@ describe('jira-wiring', () => {
 
   test('createProvider builds JiraProvider when all four required vars are set', () => {
     const { db, dbPath } = makeDb()
-    setJiraRequiredEnv()
-    const provider = createProvider(db, dbPath)
+    const provider = createProvider(
+      db,
+      {
+        provider: 'jira',
+        baseUrl: 'https://example.atlassian.net',
+        email: 'a@example.com',
+        apiToken: 'tok-test',
+        projectKey: 'ENG',
+      },
+      dbPath,
+    )
     expect(provider.type).toBe('jira')
   })
 
-  test('JIRA_BOARD_ID non-numeric falls back to undefined', () => {
-    const { db, dbPath } = makeDb()
+  test('JIRA_BOARD_ID non-numeric falls back to undefined in env loader', () => {
     setJiraRequiredEnv()
     process.env['JIRA_BOARD_ID'] = 'notanumber'
-    const provider = createProvider(db, dbPath)
-    expect(provider.type).toBe('jira')
+    const config = trackerConfigFromEnv()
+    expect(config.provider).toBe('jira')
+    expect(config).not.toHaveProperty('boardId')
+  })
+
+  test('trackerConfigFromEnv carries remote polling sync interval', () => {
+    setJiraRequiredEnv()
+    process.env['KANBAN_SYNC_INTERVAL_MS'] = '60000'
+
+    const jiraConfig = trackerConfigFromEnv()
+    expect(jiraConfig.provider).toBe('jira')
+    expect(jiraConfig.syncIntervalMs).toBe(60_000)
+
+    process.env['KANBAN_PROVIDER'] = 'linear'
+    process.env['LINEAR_API_KEY'] = 'lin_api_test'
+    process.env['LINEAR_TEAM_ID'] = 'team-test'
+    const linearConfig = trackerConfigFromEnv()
+    expect(linearConfig.provider).toBe('linear')
+    expect(linearConfig.syncIntervalMs).toBe(60_000)
   })
 
   test('kanban column add under KANBAN_PROVIDER=jira exits with UNSUPPORTED_OPERATION', async () => {
@@ -178,10 +203,15 @@ describe('jira-wiring', () => {
 
   test('KANBAN_PROVIDER=linear still builds LinearProvider (regression guard)', () => {
     const { db, dbPath } = makeDb()
-    process.env['KANBAN_PROVIDER'] = 'linear'
-    process.env['LINEAR_API_KEY'] = 'lin_api_test'
-    process.env['LINEAR_TEAM_ID'] = 'team-test'
-    const provider = createProvider(db, dbPath)
+    const provider = createProvider(
+      db,
+      {
+        provider: 'linear',
+        apiKey: 'lin_api_test',
+        teamId: 'team-test',
+      },
+      dbPath,
+    )
     expect(provider.type).toBe('linear')
   })
 })

package/src/__tests__/postgres-jira-provider.test.ts

@@ -0,0 +1,315 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import postgres from 'postgres'
+
+import { run } from '../index'
+import type { Task } from '../types'
+
+const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
+const pgTest = databaseUrl ? test : test.skip
+
+type FetchInit = RequestInit | undefined
+type StubCall = { url: string; init?: FetchInit }
+type StubHandler = (url: string, init?: FetchInit) => Response | Promise<Response>
+type StubRoute = { match: (url: string) => boolean; handler: StubHandler }
+
+function jiraFetchStub(routes: StubRoute[]): {
+  fn: typeof fetch
+  calls: StubCall[]
+} {
+  const calls: StubCall[] = []
+  const fn = (async (input: string | URL | Request, init?: FetchInit) => {
+    const url =
+      typeof input === 'string' ? input : input instanceof URL ? input.toString() : input.url
+    calls.push({ url, init })
+    for (const route of routes) {
+      if (route.match(url)) return route.handler(url, init)
+    }
+    return new Response('route not stubbed: ' + url, { status: 500 })
+  }) as unknown as typeof fetch
+  return { fn, calls }
+}
+
+function jsonResponse(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { 'content-type': 'application/json' },
+  })
+}
+
+const projectFixture = { id: '10000', key: 'ENG', name: 'Engineering' }
+
+function makeIssue(
+  overrides: Partial<{
+    id: string
+    key: string
+    summary: string
+    updated: string
+  }> = {},
+): Record<string, unknown> {
+  return {
+    id: overrides.id ?? '10001',
+    key: overrides.key ?? 'ENG-1',
+    fields: {
+      summary: overrides.summary ?? 'Postgres cached Jira issue',
+      description: null,
+      status: { id: '10', name: 'To Do' },
+      issuetype: { id: '10000', name: 'Task' },
+      priority: { id: '2', name: 'High' },
+      assignee: { accountId: 'a1', displayName: 'Alice' },
+      labels: ['garage'],
+      comment: { total: 0 },
+      created: '2026-01-01T00:00:00Z',
+      updated: overrides.updated ?? '2026-01-02T00:00:00Z',
+      project: { id: '10000', key: 'ENG' },
+    },
+  }
+}
+
+function standardRoutes(): StubRoute[] {
+  const issues = [makeIssue()]
+  const comments: Record<
+    string,
+    Array<{ id: string; body: unknown; created: string; updated: string }>
+  > = {}
+  const setIssueStatus = (issueKey: string, statusId: string, name: string): void => {
+    const issue = issues.find((candidate) => String(candidate.key) === issueKey) as
+      | { fields?: { status?: { id: string; name: string }; updated?: string } }
+      | undefined
+    if (!issue?.fields?.status) return
+    issue.fields.status = { id: statusId, name }
+    issue.fields.updated = '2026-01-06T00:00:00Z'
+  }
+  return [
+    {
+      match: (url) => url.includes('/rest/api/3/project/ENG/statuses'),
+      handler: () =>
+        jsonResponse([
+          {
+            id: 'cat-1',
+            name: 'To Do',
+            statuses: [
+              { id: '10', name: 'To Do' },
+              { id: '20', name: 'Done' },
+            ],
+          },
+        ]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/project/ENG'),
+      handler: () => jsonResponse(projectFixture),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/user/assignable/search'),
+      handler: () => jsonResponse([{ accountId: 'a1', displayName: 'Alice', active: true }]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/priority'),
+      handler: () => jsonResponse([{ id: '2', name: 'High' }]),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/issuetype/project'),
+      handler: () => jsonResponse([{ id: '10000', name: 'Task' }]),
+    },
+    {
+      match: (url) => url.endsWith('/rest/api/3/issue'),
+      handler: async (_url, init) => {
+        const body = JSON.parse(String(init?.body ?? '{}')) as {
+          fields?: { summary?: string }
+        }
+        const issue = makeIssue({
+          id: '10002',
+          key: 'ENG-2',
+          summary: body.fields?.summary ?? 'Created issue',
+          updated: '2026-01-03T00:00:00Z',
+        })
+        issues.push(issue)
+        return jsonResponse(
+          { id: '10002', key: 'ENG-2', self: 'https://example/rest/api/3/issue/10002' },
+          201,
+        )
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/ENG-\d+\/comment$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const issueKey = new URL(url).pathname.match(/\/issue\/(ENG-\d+)\/comment/)![1]!
+        if (init?.method === 'POST') {
+          const body = JSON.parse(String(init.body ?? '{}')) as { body?: unknown }
+          const row = {
+            id: `comment-${(comments[issueKey]?.length ?? 0) + 1}`,
+            body: body.body,
+            created: '2026-01-04T00:00:00Z',
+            updated: '2026-01-04T00:00:00Z',
+          }
+          comments[issueKey] = [...(comments[issueKey] ?? []), row]
+          return jsonResponse(row, 201)
+        }
+        return jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: comments[issueKey]?.length ?? 0,
+          comments: comments[issueKey] ?? [],
+        })
+      },
+    },
+    {
+      match: (url) =>
+        /\/rest\/api\/3\/issue\/ENG-\d+\/comment\/comment-\d+$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const [, issueKey, commentId] = new URL(url).pathname.match(
+          /\/issue\/(ENG-\d+)\/comment\/(comment-\d+)$/,
+        )!
+        const rows = comments[issueKey!] ?? []
+        const existing = rows.find((row) => row.id === commentId)
+        if (!existing) return jsonResponse({ errorMessages: ['missing'] }, 404)
+        if (init?.method === 'PUT') {
+          const body = JSON.parse(String(init.body ?? '{}')) as { body?: unknown }
+          existing.body = body.body
+          existing.updated = '2026-01-05T00:00:00Z'
+        }
+        return jsonResponse(existing)
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/ENG-\d+\/transitions$/.test(new URL(url).pathname),
+      handler: async (url, init) => {
+        const issueKey = new URL(url).pathname.match(/\/issue\/(ENG-\d+)\/transitions$/)![1]!
+        if (init?.method === 'POST') {
+          setIssueStatus(issueKey, '20', 'Done')
+          return new Response(null, { status: 204 })
+        }
+        return jsonResponse({
+          transitions: [{ id: 'move-done', name: 'Done', to: { id: '20', name: 'Done' } }],
+        })
+      },
+    },
+    {
+      match: (url) => /\/rest\/api\/3\/issue\/[^/]+\/changelog/.test(url),
+      handler: () =>
+        jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: 0,
+          isLast: true,
+          values: [],
+        }),
+    },
+    {
+      match: (url) => url.includes('/rest/api/3/search/jql'),
+      handler: () =>
+        jsonResponse({
+          startAt: 0,
+          maxResults: 100,
+          total: issues.length,
+          issues,
+        }),
+    },
+  ]
+}
+
+function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
+  expect(result.exitCode).toBe(0)
+  expect(result.output.ok).toBe(true)
+  if (!result.output.ok) throw new Error('expected successful CLI output')
+  return result.output.data as T
+}
+
+describe('postgres jira provider', () => {
+  let previousEnv: Record<string, string | undefined>
+  let previousFetch: typeof fetch
+  let sql: postgres.Sql | null = null
+
+  beforeEach(async () => {
+    previousFetch = globalThis.fetch
+    previousEnv = {
+      KANBAN_STORAGE: process.env['KANBAN_STORAGE'],
+      KANBAN_DATABASE_URL: process.env['KANBAN_DATABASE_URL'],
+      KANBAN_PROVIDER: process.env['KANBAN_PROVIDER'],
+      JIRA_BASE_URL: process.env['JIRA_BASE_URL'],
+      JIRA_EMAIL: process.env['JIRA_EMAIL'],
+      JIRA_API_TOKEN: process.env['JIRA_API_TOKEN'],
+      JIRA_PROJECT_KEY: process.env['JIRA_PROJECT_KEY'],
+    }
+
+    process.env['KANBAN_STORAGE'] = 'postgres'
+    process.env['KANBAN_DATABASE_URL'] = databaseUrl
+    process.env['KANBAN_PROVIDER'] = 'jira'
+    process.env['JIRA_BASE_URL'] = 'https://example.atlassian.net'
+    process.env['JIRA_EMAIL'] = 'user@example.com'
+    process.env['JIRA_API_TOKEN'] = 'token'
+    process.env['JIRA_PROJECT_KEY'] = 'ENG'
+
+    if (databaseUrl) {
+      sql = postgres(databaseUrl, { max: 1, onnotice: () => {} })
+      await sql`DROP TABLE IF EXISTS jira_activity`
+      await sql`DROP TABLE IF EXISTS jira_issues`
+      await sql`DROP TABLE IF EXISTS jira_issue_types`
+      await sql`DROP TABLE IF EXISTS jira_priorities`
+      await sql`DROP TABLE IF EXISTS jira_users`
+      await sql`DROP TABLE IF EXISTS jira_columns`
+      await sql`DROP TABLE IF EXISTS jira_sync_meta`
+    }
+
+    globalThis.fetch = jiraFetchStub(standardRoutes()).fn
+  })
+
+  afterEach(async () => {
+    globalThis.fetch = previousFetch
+    if (sql) {
+      await sql.end({ timeout: 1 })
+      sql = null
+    }
+    for (const [key, value] of Object.entries(previousEnv)) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  })
+
+  pgTest('lists Jira tasks from a shared Postgres cache through the CLI path', async () => {
+    const tasks = expectOk<Task[]>(await run(['task', 'list', '-c', 'To Do']))
+
+    expect(tasks).toHaveLength(1)
+    expect(tasks[0]).toMatchObject({
+      id: 'jira:10001',
+      externalRef: 'ENG-1',
+      title: 'Postgres cached Jira issue',
+      priority: 'high',
+      assignee: 'Alice',
+      project: 'ENG',
+    })
+  })
+
+  pgTest('creates Jira tasks and writes comments through Postgres storage', async () => {
+    const created = expectOk<Task>(
+      await run(['task', 'add', 'Created through Postgres Jira', '-p', 'high', '-a', 'Alice']),
+    )
+
+    expect(created).toMatchObject({
+      id: 'jira:10002',
+      externalRef: 'ENG-2',
+      title: 'Created through Postgres Jira',
+      priority: 'high',
+      assignee: 'Alice',
+    })
+
+    const comment = expectOk(await run(['comment', 'add', 'ENG-2', 'Garage projection comment']))
+    expect(comment).toMatchObject({
+      id: 'comment-1',
+      task_id: 'jira:10002',
+      body: 'Garage projection comment',
+    })
+
+    const comments = expectOk(await run(['comment', 'list', 'ENG-2']))
+    expect(comments).toHaveLength(1)
+  })
+
+  pgTest('moves Jira tasks through Postgres storage', async () => {
+    const moved = expectOk<Task>(await run(['task', 'move', 'ENG-1', 'Done']))
+
+    expect(moved).toMatchObject({
+      id: 'jira:10001',
+      externalRef: 'ENG-1',
+      column_id: '20',
+    })
+  })
+})