@andypai/agent-kanban 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andypai/agent-kanban",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Agent-friendly kanban board CLI. Manage tasks via bash commands, parse structured JSON output.",
   "homepage": "https://github.com/abpai/agent-kanban#readme",
   "repository": {

package/src/__tests__/api.test.ts

@@ -41,12 +41,18 @@ describe('handleRequest', () => {
     const req = new Request('http://localhost/api/tasks', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ title: 'Created via API' }),
+      body: JSON.stringify({ title: 'Created via API', labels: ['garage-smoke', 'api-smoke'] }),
     })
     const result = await handleRequest(provider, req)
+    const body = (await result.response.json()) as {
+      ok: boolean
+      data: { labels: string[] }
+    }
 
     expect(result.response.status).toBe(200)
     expect(result.mutated).toBe(true)
+    expect(body.ok).toBe(true)
+    expect(body.data.labels).toEqual(['garage-smoke', 'api-smoke'])
   })
 
   test('marks successful task delete as mutated', async () => {

package/src/__tests__/board-utils.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, test } from 'bun:test'
-import { replaceTask, upsertTaskInColumn } from '../../ui/src/components/boardUtils'
+import {
+  moveTaskInBoard,
+  replaceTask,
+  upsertTaskInColumn,
+} from '../../ui/src/components/boardUtils'
 import type { BoardView, Task } from '../../ui/src/types'
 
 function makeTask(
@@ -97,4 +101,36 @@ describe('boardUtils', () => {
     expect(nextBoard.columns[0]!.tasks.map((task) => task.id)).toEqual(['t-1', 'tmp-1', 't-2'])
     expect(nextBoard.columns[0]!.tasks[0]!.title).toBe('First edited')
   })
+
+  test('moveTaskInBoard accepts a column id when column names repeat', () => {
+    const board: BoardView = {
+      columns: [
+        {
+          id: 'board:1006:Backlog',
+          name: 'Backlog',
+          position: 0,
+          color: null,
+          created_at: '',
+          updated_at: '',
+          tasks: [
+            makeTask({ id: 't-1', title: 'First', column_id: 'board:1006:Backlog', position: 0 }),
+          ],
+        },
+        {
+          id: 'board:1006:Backlog:1',
+          name: 'Backlog',
+          position: 1,
+          color: null,
+          created_at: '',
+          updated_at: '',
+          tasks: [],
+        },
+      ],
+    }
+
+    const nextBoard = moveTaskInBoard(board, 't-1', 'board:1006:Backlog:1')
+
+    expect(nextBoard.columns[0]!.tasks).toEqual([])
+    expect(nextBoard.columns[1]!.tasks.map((task) => task.id)).toEqual(['t-1'])
+  })
 })

package/src/__tests__/db.test.ts

@@ -79,7 +79,7 @@ describe('schema', () => {
     expect(listColumns(db)).toHaveLength(5)
   })
 
-  test('migrateSchema adds project column and index to legacy tasks table', () => {
+  test('migrateSchema adds project and labels columns to legacy tasks table', () => {
     const legacy = new Database(':memory:')
     legacy.run(
       `CREATE TABLE tasks (
@@ -102,6 +102,7 @@ describe('schema', () => {
     const indexes = legacy.query('PRAGMA index_list(tasks)').all() as { name: string }[]
 
     expect(columns.some((c) => c.name === 'project')).toBe(true)
+    expect(columns.some((c) => c.name === 'labels')).toBe(true)
     expect(indexes.some((i) => i.name === 'idx_tasks_project')).toBe(true)
   })
 

package/src/__tests__/index.test.ts

@@ -165,6 +165,10 @@ describe('run', () => {
           'alice',
           '--project',
           'Platform',
+          '--label',
+          'garage-smoke',
+          '--label',
+          'garage-owner-local,smoke-run',
           '-m',
           '{"sprint":5}',
         ]),
@@ -174,6 +178,7 @@ describe('run', () => {
       expect(created.priority).toBe('high')
       expect(created.assignee).toBe('alice')
       expect(created.project).toBe('Platform')
+      expect(created.labels).toEqual(['garage-smoke', 'garage-owner-local', 'smoke-run'])
       expect(created.metadata).toBe('{"sprint":5}')
 
       const listed = expectOk<Task[]>(

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

@@ -352,6 +352,7 @@ describe('JiraProvider mutations', () => {
       description: 'hello\n- item',
       priority: 'high',
       assignee: 'Alice',
+      labels: ['garage-smoke', 'garage-owner-local'],
     })
 
     expect(task.externalRef).toBe('ENG-10')
@@ -365,6 +366,7 @@ describe('JiraProvider mutations', () => {
     expect((body.fields.priority as { name: string }).name).toBe('High')
     expect((body.fields.assignee as { accountId: string }).accountId).toBe('a-1')
     expect((body.fields.project as { key: string }).key).toBe('ENG')
+    expect(body.fields.labels).toEqual(['garage-smoke', 'garage-owner-local'])
     const desc = body.fields.description as {
       version: number
       type: string

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

@@ -229,6 +229,35 @@ describe('JiraProvider read path', () => {
     expect(decodeColumnStatusIds(cols[0]!)).toEqual(['10001', '10002'])
   })
 
+  test('sync keeps duplicate Jira board column names as distinct cached columns', async () => {
+    const { provider } = makeProviderWithBoard(
+      standardRoutes({
+        boardCfg: {
+          id: 1006,
+          name: 'ENG Board',
+          columnConfig: {
+            columns: [
+              { name: 'Backlog', statuses: [{ id: '10001' }] },
+              { name: 'Backlog', statuses: [{ id: '10002' }] },
+            ],
+          },
+        },
+      }),
+      1006,
+    )
+
+    await provider.getBoard()
+
+    const cols = getCachedColumns(db)
+    expect(cols.map((column) => column.id)).toEqual(['board:1006:Backlog', 'board:1006:Backlog:1'])
+    expect(cols.map((column) => decodeColumnStatusIds(column))).toEqual([['10001'], ['10002']])
+    await expect(provider.listTasks({ column: 'Backlog' })).rejects.toMatchObject({
+      code: ErrorCode.COLUMN_NOT_FOUND,
+      message: expect.stringContaining('ambiguous'),
+    })
+    expect(await provider.listTasks({ column: 'board:1006:Backlog' })).toEqual([])
+  })
+
   test('sync populates columns from statuses when boardId is absent', async () => {
     const { provider } = makeProvider(standardRoutes({}))
     await provider.getBoard()

package/src/__tests__/linear-provider-sync.test.ts

@@ -133,15 +133,32 @@ describe('LinearProvider sync', () => {
       lastIssueUpdatedAt: '2026-01-02T00:00:00Z',
     })
 
-    let createIssueTeamId: string | null = null
+    const createIssueInput: { current?: { labelIds?: string[]; teamId?: string } } = {}
     globalThis.fetch = (async (_input: string | URL | Request, init?: RequestInit) => {
       const body = JSON.parse(String(init?.body)) as {
         query: string
-        variables: { input?: { teamId?: string } }
+        variables: { input?: { labelIds?: string[]; teamId?: string } }
+      }
+
+      if (body.query.includes('query IssueLabels')) {
+        return new Response(
+          JSON.stringify({
+            data: {
+              issueLabels: {
+                nodes: [
+                  { id: 'label-smoke', name: 'garage-smoke' },
+                  { id: 'label-owner', name: 'garage-owner-local' },
+                ],
+                pageInfo: { hasNextPage: false, endCursor: null },
+              },
+            },
+          }),
+          { status: 200, headers: { 'content-type': 'application/json' } },
+        )
       }
 
       if (body.query.includes('mutation CreateIssue')) {
-        createIssueTeamId = body.variables.input?.teamId ?? null
+        createIssueInput.current = body.variables.input
         return new Response(
           JSON.stringify({
             data: {
@@ -159,7 +176,12 @@ describe('LinearProvider sync', () => {
                   assignee: null,
                   project: null,
                   state: { id: 'state-1', name: 'Todo', position: 0 },
-                  labels: { nodes: [] },
+                  labels: {
+                    nodes: [
+                      { id: 'label-smoke', name: 'garage-smoke' },
+                      { id: 'label-owner', name: 'garage-owner-local' },
+                    ],
+                  },
                   comments: {
                     nodes: [],
                     pageInfo: { hasNextPage: false, endCursor: null },
@@ -176,10 +198,15 @@ describe('LinearProvider sync', () => {
     }) as unknown as typeof fetch
 
     const provider = new LinearProvider(db, 'R2P', 'lin_api_test')
-    const created = await provider.createTask({ title: 'Hello' })
+    const created = await provider.createTask({
+      title: 'Hello',
+      labels: ['garage-smoke', 'garage-owner-local'],
+    })
 
-    expect(String(createIssueTeamId)).toBe('3ca24047-e954-44e8-b266-c7182410befb')
+    expect(createIssueInput.current?.teamId).toBe('3ca24047-e954-44e8-b266-c7182410befb')
+    expect(createIssueInput.current?.labelIds).toEqual(['label-smoke', 'label-owner'])
     expect(created.externalRef).toBe('R2P-1')
+    expect(created.labels).toEqual(['garage-smoke', 'garage-owner-local'])
   })
 
   test('periodic full sync prunes cached issues missing from upstream', async () => {

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

@@ -3,6 +3,7 @@ import postgres from 'postgres'
 
 import { run } from '../index'
 import type { Task } from '../types'
+import { PostgresJiraProvider } from '../providers/postgres-jira'
 
 const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
 const pgTest = databaseUrl ? test : test.skip
@@ -43,6 +44,7 @@ function makeIssue(
     id: string
     key: string
     summary: string
+    labels: string[]
     updated: string
   }> = {},
 ): Record<string, unknown> {
@@ -56,7 +58,7 @@ function makeIssue(
       issuetype: { id: '10000', name: 'Task' },
       priority: { id: '2', name: 'High' },
       assignee: { accountId: 'a1', displayName: 'Alice' },
-      labels: ['garage'],
+      labels: overrides.labels ?? ['garage'],
       comment: { total: 0 },
       created: '2026-01-01T00:00:00Z',
       updated: overrides.updated ?? '2026-01-02T00:00:00Z',
@@ -65,7 +67,7 @@ function makeIssue(
   }
 }
 
-function standardRoutes(): StubRoute[] {
+function standardRoutes(opts: { boardCfg?: unknown } = {}): StubRoute[] {
   const issues = [makeIssue()]
   const comments: Record<
     string,
@@ -98,6 +100,19 @@ function standardRoutes(): StubRoute[] {
       match: (url) => url.includes('/rest/api/3/project/ENG'),
       handler: () => jsonResponse(projectFixture),
     },
+    {
+      match: (url) => url.includes('/rest/agile/1.0/board/'),
+      handler: () =>
+        jsonResponse(
+          opts.boardCfg ?? {
+            id: 1006,
+            name: 'ENG Board',
+            columnConfig: {
+              columns: [{ name: 'Done', statuses: [{ id: '10' }, { id: '20' }] }],
+            },
+          },
+        ),
+    },
     {
       match: (url) => url.includes('/rest/api/3/user/assignable/search'),
       handler: () => jsonResponse([{ accountId: 'a1', displayName: 'Alice', active: true }]),
@@ -114,12 +129,13 @@ function standardRoutes(): StubRoute[] {
       match: (url) => url.endsWith('/rest/api/3/issue'),
       handler: async (_url, init) => {
         const body = JSON.parse(String(init?.body ?? '{}')) as {
-          fields?: { summary?: string }
+          fields?: { labels?: string[]; summary?: string }
         }
         const issue = makeIssue({
           id: '10002',
           key: 'ENG-2',
           summary: body.fields?.summary ?? 'Created issue',
+          labels: body.fields?.labels,
           updated: '2026-01-03T00:00:00Z',
         })
         issues.push(issue)
@@ -303,6 +319,79 @@ describe('postgres jira provider', () => {
     expect(comments).toHaveLength(1)
   })
 
+  pgTest('passes labels when creating Jira tasks through Postgres storage', async () => {
+    expect(sql).not.toBeNull()
+    if (!sql) throw new Error('expected postgres test connection')
+    const stub = jiraFetchStub(standardRoutes())
+    globalThis.fetch = stub.fn
+    const provider = new PostgresJiraProvider(sql, {
+      baseUrl: 'https://example.atlassian.net',
+      email: 'user@example.com',
+      apiToken: 'token',
+      projectKey: 'ENG',
+    })
+
+    const created = await provider.createTask({
+      title: 'Created with labels',
+      labels: ['garage-smoke', 'garage-owner-local'],
+    })
+
+    expect(created.labels).toEqual(['garage-smoke', 'garage-owner-local'])
+    const postCall = stub.calls.find(
+      (call) => call.init?.method === 'POST' && call.url.endsWith('/rest/api/3/issue'),
+    )
+    expect(postCall).toBeDefined()
+    const body = JSON.parse(String(postCall?.init?.body ?? '{}')) as {
+      fields?: Record<string, unknown>
+    }
+    expect(body.fields?.labels).toEqual(['garage-smoke', 'garage-owner-local'])
+  })
+
+  pgTest('keeps duplicate Jira board column names as distinct cached columns', async () => {
+    expect(sql).not.toBeNull()
+    if (!sql) throw new Error('expected postgres test connection')
+    const stub = jiraFetchStub(
+      standardRoutes({
+        boardCfg: {
+          id: 1006,
+          name: 'ENG Board',
+          columnConfig: {
+            columns: [
+              { name: 'Backlog', statuses: [{ id: '10' }] },
+              { name: 'Backlog', statuses: [{ id: '20' }] },
+            ],
+          },
+        },
+      }),
+    )
+    globalThis.fetch = stub.fn
+    const provider = new PostgresJiraProvider(sql, {
+      baseUrl: 'https://example.atlassian.net',
+      email: 'user@example.com',
+      apiToken: 'token',
+      projectKey: 'ENG',
+      boardId: 1006,
+    })
+
+    const board = await provider.getBoard()
+
+    expect(board.columns.map((column) => column.id)).toEqual([
+      'board:1006:Backlog',
+      'board:1006:Backlog:1',
+    ])
+    expect(board.columns.map((column) => column.tasks.map((task) => task.externalRef))).toEqual([
+      ['ENG-1'],
+      [],
+    ])
+    await expect(provider.listTasks({ column: 'Backlog' })).rejects.toMatchObject({
+      code: 'COLUMN_NOT_FOUND',
+      message: expect.stringContaining('ambiguous'),
+    })
+    expect(
+      (await provider.listTasks({ column: 'board:1006:Backlog' })).map((task) => task.id),
+    ).toEqual(['jira:10001'])
+  })
+
   pgTest('moves Jira tasks through Postgres storage', async () => {
     const moved = expectOk<Task>(await run(['task', 'move', 'ENG-1', 'Done']))
 

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

@@ -3,6 +3,7 @@ import postgres from 'postgres'
 
 import { run } from '../index'
 import type { Task, TaskComment } from '../types'
+import { PostgresLinearProvider } from '../providers/postgres-linear'
 
 const databaseUrl = process.env['KANBAN_PG_TEST_URL'] ?? process.env['DATABASE_URL']
 const pgTest = databaseUrl ? test : test.skip
@@ -31,6 +32,8 @@ type StubComment = {
   user: { id: string; name: string; displayName: string }
 }
 
+type LinearStubCall = { query: string; variables: Record<string, unknown> }
+
 function expectOk<T>(result: Awaited<ReturnType<typeof run>>): T {
   expect(result.exitCode).toBe(0)
   expect(result.output.ok).toBe(true)
@@ -64,7 +67,7 @@ function makeIssue(overrides: Partial<StubIssue> = {}): StubIssue {
   }
 }
 
-function linearFetchStub(): typeof fetch {
+function linearFetchStub(calls: LinearStubCall[] = []): typeof fetch {
   const commentsByIssue = new Map<string, StubComment[]>()
   const issues: StubIssue[] = [makeIssue()]
   const states = [
@@ -83,6 +86,12 @@ function linearFetchStub(): typeof fetch {
       { id: 'proj-1', name: 'Garage', url: 'https://linear.app/project/garage', state: 'started' },
     ],
   }
+  const labels = {
+    nodes: [
+      { id: 'label-smoke', name: 'garage-smoke' },
+      { id: 'label-owner', name: 'garage-owner-local' },
+    ],
+  }
 
   return (async (_input: string | URL | Request, init?: RequestInit) => {
     const body = JSON.parse(String(init?.body ?? '{}')) as {
@@ -91,6 +100,7 @@ function linearFetchStub(): typeof fetch {
     }
     const query = body.query
     const variables = body.variables ?? {}
+    calls.push({ query, variables })
 
     if (query.includes('query TeamSnapshot')) {
       return Response.json({ data: { team } })
@@ -101,6 +111,16 @@ function linearFetchStub(): typeof fetch {
     if (query.includes('query Projects')) {
       return Response.json({ data: { projects } })
     }
+    if (query.includes('query IssueLabels')) {
+      return Response.json({
+        data: {
+          issueLabels: {
+            ...labels,
+            pageInfo: { hasNextPage: false, endCursor: null },
+          },
+        },
+      })
+    }
     if (query.includes('query Issues')) {
       return Response.json({
         data: {
@@ -119,8 +139,10 @@ function linearFetchStub(): typeof fetch {
         stateId?: string
         assigneeId?: string
         projectId?: string
+        labelIds?: string[]
       }
       const state = states.find((candidate) => candidate.id === input.stateId) ?? states[0]!
+      const issueLabels = labels.nodes.filter((label) => input.labelIds?.includes(label.id))
       const issue = makeIssue({
         id: 'lin-2',
         identifier: 'GB-2',
@@ -130,6 +152,7 @@ function linearFetchStub(): typeof fetch {
         state,
         assignee: users.nodes.find((user) => user.id === input.assigneeId) ?? null,
         project: projects.nodes.find((project) => project.id === input.projectId) ?? null,
+        labels: { nodes: issueLabels },
         updatedAt: '2026-01-03T00:00:00.000Z',
       })
       issues.push(issue)
@@ -306,4 +329,26 @@ describe('postgres linear provider', () => {
     const comments = expectOk<TaskComment[]>(await run(['comment', 'list', 'GB-2']))
     expect(comments).toHaveLength(1)
   })
+
+  pgTest('passes labels when creating Linear tasks through Postgres storage', async () => {
+    expect(sql).not.toBeNull()
+    if (!sql) throw new Error('expected postgres test connection')
+
+    const calls: LinearStubCall[] = []
+    globalThis.fetch = linearFetchStub(calls)
+    const provider = new PostgresLinearProvider(sql, 'GB', 'linear-key')
+
+    const created = await provider.createTask({
+      title: 'Created with labels',
+      labels: ['garage-smoke', 'garage-owner-local'],
+    })
+
+    expect(created.labels).toEqual(['garage-smoke', 'garage-owner-local'])
+    const createCall = calls.find((call) => call.query.includes('mutation CreateIssue'))
+    expect(createCall).toBeDefined()
+    expect((createCall?.variables.input as { labelIds?: string[] })?.labelIds).toEqual([
+      'label-smoke',
+      'label-owner',
+    ])
+  })
 })

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

@@ -78,6 +78,10 @@ describe('postgres local provider', () => {
         'garage',
         '--project',
         'Dispatch',
+        '--label',
+        'garage-smoke',
+        '--label',
+        'postgres-local',
         '-m',
         '{"storage":"postgres"}',
       ]),
@@ -85,6 +89,7 @@ describe('postgres local provider', () => {
 
     expect(created.title).toBe('Postgres-backed task')
     expect(created.column_name).toBe('recurring')
+    expect(created.labels).toEqual(['garage-smoke', 'postgres-local'])
     expect(created.version).toBe('0')
 
     const listed = expectOk<Task[]>(await run(['task', 'list', '-c', 'recurring']))

package/src/api.ts

@@ -1,6 +1,7 @@
 import { KanbanError, ErrorCode } from './errors'
 import type { BoardConfig, CliOutput, Task } from './types'
 import type { CreateTaskInput, UpdateTaskInput, KanbanProvider } from './providers/types'
+import { normalizeLabels } from './labels'
 
 export type WsEvent =
   | { type: 'task:upsert'; task: Task; columnName: string }
@@ -146,6 +147,7 @@ export async function handleRequest(provider: KanbanProvider, req: Request): Pro
         priority: body.priority,
         assignee: body.assignee,
         project: body.project,
+        labels: normalizeLabels(body.labels),
         metadata: body.metadata,
       })
       return { ok: true, data: created }

package/src/db.ts

@@ -6,6 +6,7 @@ import { generateId } from './id'
 import { ErrorCode, KanbanError } from './errors'
 import type { BoardView, Column, Priority, Task, TaskComment, TaskWithColumn } from './types'
 import { logActivity, enterColumn, exitColumn } from './activity'
+import { normalizeLabels, parseStoredLabels } from './labels'
 
 const DEFAULT_COLUMNS = [
   { name: 'recurring', position: 0 },
@@ -63,6 +64,7 @@ export function initSchema(db: Database): void {
       priority TEXT NOT NULL DEFAULT 'medium' CHECK (priority IN ('low','medium','high','urgent')),
       assignee TEXT NOT NULL DEFAULT '',
       project TEXT NOT NULL DEFAULT '',
+      labels TEXT NOT NULL DEFAULT '[]',
       metadata TEXT NOT NULL DEFAULT '{}',
       revision INTEGER NOT NULL DEFAULT 0,
       created_at TEXT NOT NULL DEFAULT (datetime('now')),
@@ -124,6 +126,10 @@ export function migrateSchema(db: Database): void {
   if (!hasProject) {
     db.run("ALTER TABLE tasks ADD COLUMN project TEXT NOT NULL DEFAULT ''")
   }
+  const hasLabels = columns.some((c) => c.name === 'labels')
+  if (!hasLabels) {
+    db.run("ALTER TABLE tasks ADD COLUMN labels TEXT NOT NULL DEFAULT '[]'")
+  }
   const hasRevision = columns.some((c) => c.name === 'revision')
   if (!hasRevision) {
     db.run('ALTER TABLE tasks ADD COLUMN revision INTEGER NOT NULL DEFAULT 0')
@@ -276,6 +282,7 @@ export function addTask(
     priority?: Priority
     assignee?: string
     project?: string
+    labels?: string[]
     metadata?: string
   } = {},
 ): TaskWithColumn {
@@ -297,13 +304,14 @@ export function addTask(
   }
 
   const id = generateId('t')
+  const labels = normalizeLabels(opts.labels)
   const maxPos = db
     .query('SELECT COALESCE(MAX(position), -1) + 1 as next FROM tasks WHERE column_id = $col')
     .get({ $col: column.id }) as { next: number }
 
   db.query(
-    `INSERT INTO tasks (id, title, description, column_id, position, priority, assignee, project, metadata)
-     VALUES ($id, $title, $desc, $col, $pos, $pri, $assignee, $project, $meta)`,
+    `INSERT INTO tasks (id, title, description, column_id, position, priority, assignee, project, labels, metadata)
+     VALUES ($id, $title, $desc, $col, $pos, $pri, $assignee, $project, $labels, $meta)`,
   ).run({
     $id: id,
     $title: title,
@@ -313,6 +321,7 @@ export function addTask(
     $pri: opts.priority ?? 'medium',
     $assignee: opts.assignee ?? '',
     $project: opts.project ?? '',
+    $labels: JSON.stringify(labels),
     $meta: opts.metadata ?? '{}',
   })
   logActivity(db, id, 'created', { new_value: title })
@@ -330,7 +339,7 @@ export function getTask(db: Database, id: string): TaskWithColumn {
   if (!task) {
     throw new KanbanError(ErrorCode.TASK_NOT_FOUND, `No task with id '${id}'`)
   }
-  return task
+  return hydrateTask(task)
 }
 
 export function listTasks(
@@ -384,7 +393,8 @@ export function listTasks(
        JOIN columns c ON t.column_id = c.id
        ${where} ORDER BY ${orderBy} ${limitClause}`,
     )
-    .all(params as Record<string, string>) as TaskWithColumn[]
+    .all(params as Record<string, string>)
+    .map((task) => hydrateTask(task as TaskWithColumn))
 }
 
 export function updateTask(
@@ -630,11 +640,18 @@ export function getBoardView(db: Database): BoardView {
       ...col,
       tasks: db
         .query('SELECT * FROM tasks WHERE column_id = $col ORDER BY position')
-        .all({ $col: col.id }) as Task[],
+        .all({ $col: col.id })
+        .map((task) => hydrateTask(task as Task)),
     })),
   }
 }
 
+function hydrateTask<T extends { labels?: unknown }>(
+  task: T,
+): Omit<T, 'labels'> & { labels: string[] } {
+  return { ...task, labels: parseStoredLabels(task.labels) }
+}
+
 // --- Bulk ---
 
 export function bulkMoveAll(

package/src/index.ts

@@ -15,6 +15,7 @@ import { openKanbanRuntime } from './provider-runtime'
 import { trackerConfigFromEnv } from './tracker-config'
 import type { KanbanProvider } from './providers/types'
 import { resolvePollingSyncIntervalMs } from './sync-config'
+import { normalizeLabels } from './labels'
 
 interface ParsedArgs {
   values: Record<string, unknown>
@@ -34,6 +35,8 @@ function parseCliArgs(argv: string[]): ParsedArgs {
       a: { type: 'string' },
       m: { type: 'string' },
       l: { type: 'string' },
+      label: { type: 'string', multiple: true },
+      labels: { type: 'string', multiple: true },
       sort: { type: 'string' },
       title: { type: 'string' },
       position: { type: 'string' },
@@ -68,6 +71,7 @@ async function routeTask(
           priority: values.p as Priority | undefined,
           assignee: values.a as string | undefined,
           project: values.project as string | undefined,
+          labels: normalizeLabels([values.label, values.labels]),
           metadata: values.m as string | undefined,
         }),
       )
@@ -388,7 +392,7 @@ Commands:
   board view                  View full board (default)
   board reset                 Reset board to defaults
 
-  task add <title>            Add a task [-d desc] [-c column] [-p priority] [-a assignee] [--project name] [-m json]
+  task add <title>            Add a task [-d desc] [-c column] [-p priority] [-a assignee] [--project name] [--label name] [-m json]
   task list                   List tasks [-c column] [-p priority] [-a assignee] [--project name] [-l limit] [--sort field]
   task view <id>              View task details
   task update <id>            Update task [--title] [-d] [-p] [-a] [--project name] [-m]