open-wadah 1.2.1 → 1.2.3

package/README.md

@@ -1,6 +1,6 @@
 # open-wadah
 
-Open Wadah CLI — shared task board for humans and agents. Use it from the terminal or from Cursor, Claude Code, and Kimi.
+Open WADAH CLI — shared task board for humans and agents. Use it from the terminal or from Cursor, Claude Code, and Kimi.
 
 ## Install
 
@@ -27,7 +27,7 @@ wadah complete <task-id>
 | Command | Description |
 |--------|-------------|
 | **Auth** | `login`, `signup`, `logout`, `whoami` |
-| **Tasks** | `open`, `list`, `search`, `requested`, `add`, `complete`, `reopen`, `view`, `update`, `move`, `assign`, `comment`, `delete` |
+| **Tasks** | `open`, `list`, `search`, `requested`, `add`, `complete`, `reopen`, `view`, `update`, `move`, `assign`, `comment`, `subtask list/add/toggle/delete`, `delete` |
 | **Relationships** | `add --blocks <id>`, `add --blocked-by <id>`, `update --blocks <id>` |
 | **Board** | `boards --json`, `buckets --json`, `assignees --json`; `board create/delete`, `bucket create/update/delete`, `assignee create/update/delete` |
 | **Files** | `folders`, `files`, `folder create` / `mkdir`, `upload` |
@@ -39,6 +39,15 @@ wadah complete <task-id>
 
 Run `wadah --help` for full list and options.
 
+Subtask examples:
+
+```bash
+wadah subtask add <task-id> "Write tests"
+wadah subtask list <task-id>
+wadah subtask toggle <task-id> <subtask-id>
+wadah subtask delete <task-id> <subtask-id>
+```
+
 ## Shell completion
 
 **Bash:**

package/cli.js

@@ -164,7 +164,10 @@ function printTaskList(tasks, state) {
   }
   tasks.forEach((t) => {
     const bucket    = bucketMap[t.bucketId]     ?? '—'
-    const assignee  = assigneeMap[t.assigneeId] ?? 'Unassigned'
+    const assignedIds = taskAssigneeIds(t)
+    const assignee = assignedIds.length === 0
+      ? 'Unassigned'
+      : assignedIds.map((id) => assigneeMap[id] ?? id).join(', ')
     const requester = t.requestedById ? assigneeMap[t.requestedById] : null
     const board     = boardMap[t.boardId]       ?? '—'
     const id        = t.id.slice(0, 8)
@@ -216,6 +219,12 @@ async function resolveMyAssigneeId(state) {
   try {
     const me = await api('/api/auth/me')
     if (me.assigneeId) return me.assigneeId
+    // For agent tokens the API always returns assigneeId if the token is linked
+    // to an assignee. If it's missing, don't fall back to the human "Me" —
+    // return null so callers know the agent has no assignee configured.
+    if (me.workspaces?.[0]?.role === 'agent') {
+      return null
+    }
     const userId = me.user?.id
     const byUserId = state.assignees.find((a) => a.user_id === userId)
     if (byUserId) return byUserId.id
@@ -228,6 +237,38 @@ function findAssignee(assignees, name) {
   return assignees.find((a) => a.name.toLowerCase().includes(q)) ?? null
 }
 
+function taskAssigneeIds(task) {
+  if (Array.isArray(task.assigneeIds) && task.assigneeIds.length > 0) return task.assigneeIds
+  if (task.assigneeId) return [task.assigneeId]
+  return []
+}
+
+function taskHasAssignee(task, assigneeId) {
+  return taskAssigneeIds(task).includes(assigneeId)
+}
+
+function resolveAssigneeIdsByNames(assignees, namesCsv) {
+  const parts = String(namesCsv ?? '')
+    .split(',')
+    .map((x) => x.trim())
+    .filter(Boolean)
+  const ids = []
+  for (const name of parts) {
+    const a = findAssignee(assignees, name)
+    if (!a) throw new CliError('validation_error', `Assignee not found: ${name}`)
+    ids.push(a.id)
+  }
+  const uniqueIds = Array.from(new Set(ids))
+  const selected = uniqueIds
+    .map((id) => assignees.find((a) => a.id === id))
+    .filter(Boolean)
+  const agentCount = selected.filter((a) => a.type === 'agent').length
+  if (agentCount > 1) {
+    throw new CliError('validation_error', 'Only one agent can be assigned to a task.')
+  }
+  return uniqueIds
+}
+
 function findBoard(boards, query) {
   const q = query.toLowerCase()
   return boards.find((b) => b.id === query || b.name.toLowerCase().includes(q)) ?? null
@@ -238,6 +279,23 @@ function findBucket(buckets, query) {
   return buckets.find((b) => b.id === query || b.title.toLowerCase().includes(q)) ?? null
 }
 
+function findSubtask(subtasks, query) {
+  const raw = String(query ?? '').trim()
+  if (!raw) return null
+  const q = raw.toLowerCase()
+  const byId = subtasks.filter((s) => s.id === raw || s.id.startsWith(raw))
+  if (byId.length === 1) return byId[0]
+  if (byId.length > 1) {
+    throw new CliError('validation_error', `Ambiguous subtask id prefix: ${raw}`)
+  }
+  const byTitle = subtasks.filter((s) => String(s.title ?? '').toLowerCase() === q)
+  if (byTitle.length === 1) return byTitle[0]
+  if (byTitle.length > 1) {
+    throw new CliError('validation_error', `Multiple subtasks have title: ${raw}`)
+  }
+  return null
+}
+
 function parseCompletedFlag(value) {
   if (typeof value !== 'string') return null
   const v = value.trim().toLowerCase()
@@ -246,6 +304,46 @@ function parseCompletedFlag(value) {
   throw new CliError('validation_error', '--completed must be true or false')
 }
 
+function parseGitHubRepoInput(input) {
+  const raw = String(input ?? '').trim()
+  if (!raw) return null
+  const bare = raw.replace(/^git\+/, '').replace(/\.git$/i, '').trim()
+  let owner = ''
+  let name = ''
+
+  const sshMatch = bare.match(/^git@github\.com:([^/]+)\/([^/]+)$/i)
+  if (sshMatch) {
+    owner = sshMatch[1]
+    name = sshMatch[2]
+  } else if (/^https?:\/\//i.test(bare)) {
+    try {
+      const u = new URL(bare)
+      if (!/^github\.com$/i.test(u.hostname)) return null
+      const parts = u.pathname.split('/').filter(Boolean)
+      if (parts.length < 2) return null
+      owner = parts[0]
+      name = parts[1]
+    } catch {
+      return null
+    }
+  } else {
+    const parts = bare.split('/').filter(Boolean)
+    if (parts.length !== 2) return null
+    owner = parts[0]
+    name = parts[1]
+  }
+
+  owner = owner.replace(/[^a-zA-Z0-9-]/g, '')
+  name = name.replace(/[^a-zA-Z0-9._-]/g, '')
+  if (!owner || !name) return null
+  return {
+    owner: owner.toLowerCase(),
+    name: name.toLowerCase(),
+    fullName: `${owner.toLowerCase()}/${name.toLowerCase()}`,
+    url: `https://github.com/${owner.toLowerCase()}/${name.toLowerCase()}`,
+  }
+}
+
 function fail(message) {
   throw new CliError('validation_error', message)
 }
@@ -303,7 +401,7 @@ Available commands and their args (use these exact command names):
 - assignees: args = []. List assignees.
 - state: args = []. Full state JSON.
 - move: args = [task id, bucket name or id]. Move task to another column.
-- assign: args = [task id, assignee name]. Assign a task.
+- assign: args = [task id, "--to", "assignee[,assignee2]", "--mode", "set|add|remove"]. Assign one or more people.
 - whoami: args = []. Show current user/workspace.
 - folders: args = []. List folders.
 - files: args = []. List files; optionally include "--folder", "<id>" in args.
@@ -326,6 +424,11 @@ Available commands and their args (use these exact command names):
 - assignee create: args = [name]. Optional "--type", "human" or "agent".
 - assignee update: args = [assignee id]. Optional "--name", "--type".
 - assignee delete: args = [assignee id]. Delete assignee.
+- repo add: args = [github url or owner/repo]. Link a GitHub repository to your workspace.
+- repo list (or repos): args = []. List linked GitHub repositories.
+- repo remove: args = [repo id]. Unlink a repository.
+- pr link: args = [task id, pr url]. Attach a PR URL to a task.
+- pr open: args = [task id]. Open the linked PR URL for a task.
 
 If the request is unclear or not a valid CLI action, return {"command": "", "args": []}. Output only the JSON object.`
 
@@ -707,12 +810,12 @@ program
 
       if (!opts.all && !opts.assignee) {
         const myId = await resolveMyAssigneeId(state)
-        if (myId) tasks = tasks.filter((t) => t.assigneeId === myId)
+        if (myId) tasks = tasks.filter((t) => taskHasAssignee(t, myId))
       }
       if (opts.assignee) {
         const a = findAssignee(state.assignees, opts.assignee)
         if (!a) return fail(`Assignee not found: ${opts.assignee}`)
-        tasks = tasks.filter((t) => t.assigneeId === a.id)
+        tasks = tasks.filter((t) => taskHasAssignee(t, a.id))
       }
       if (opts.requestedBy) {
         const a = findAssignee(state.assignees, opts.requestedBy)
@@ -749,7 +852,7 @@ program
       if (opts.assignee) {
         const a = findAssignee(state.assignees, opts.assignee)
         if (!a) return fail(`Assignee not found: ${opts.assignee}`)
-        tasks = tasks.filter((t) => t.assigneeId === a.id)
+        tasks = tasks.filter((t) => taskHasAssignee(t, a.id))
       }
       if (opts.requestedBy) {
         const a = findAssignee(state.assignees, opts.requestedBy)
@@ -790,7 +893,7 @@ program
       if (opts.assignee) {
         const a = findAssignee(state.assignees, opts.assignee)
         if (!a) return fail(`Assignee not found: ${opts.assignee}`)
-        tasks = tasks.filter((t) => t.assigneeId === a.id)
+        tasks = tasks.filter((t) => taskHasAssignee(t, a.id))
       }
 
       tasks = tasks.filter((t) =>
@@ -828,9 +931,11 @@ program
   .command('add <title>')
   .description('Create a new task')
   .option('--assignee <name>',  'Assign to a person or agent')
+  .option('--assignees <names>', 'Assign to multiple people (comma-separated names)')
   .option('--bucket <name>',    'Column name (default: first column)')
   .option('--board <name>',     'Board name (default: current board)')
   .option('--due <YYYY-MM-DD>', 'Due date')
+  .option('--priority <level>', 'Priority: urgent, high, medium, low')
   .option('--repo <owner/repo>','GitHub repo')
   .option('--url <url>',        'Issue / PR URL')
   .option('--notes <text>',     'Notes')
@@ -842,20 +947,31 @@ program
       const myId  = await resolveMyAssigneeId(state)
 
       let assigneeId    = myId
+      let assigneeIds   = assigneeId ? [assigneeId] : []
       let requestedById = null
 
+      if (opts.assignee && opts.assignees) {
+        return fail('Use either --assignee or --assignees, not both.')
+      }
       if (opts.assignee) {
         const a = findAssignee(state.assignees, opts.assignee)
         if (!a) return fail(`Assignee not found: ${opts.assignee}`)
         assigneeId    = a.id
+        assigneeIds   = [a.id]
+        requestedById = myId
+      } else if (opts.assignees) {
+        assigneeIds = resolveAssigneeIdsByNames(state.assignees, opts.assignees)
+        assigneeId = assigneeIds[0] ?? null
         requestedById = myId
       }
 
-      const board = opts.board
-        ? state.boards.find((b) => b.name.toLowerCase().includes(opts.board.toLowerCase()))
+      const defaultBoardName = opts.board ?? confGet('default_board')
+      const board = defaultBoardName
+        ? state.boards.find((b) => b.name.toLowerCase().includes(defaultBoardName.toLowerCase()))
         : state.boards.find((b) => b.id === state.currentBoardId) ?? state.boards[0]
 
       if (!board && opts.board) return fail(`Board not found: ${opts.board}`)
+      if (!board && defaultBoardName && !opts.board) return fail(`Default board not found: "${defaultBoardName}". Update with: wadah config --default-board "<name>"`)
       if (!board) console.warn(chalk.yellow(`  ⚠ No board specified — defaulting to "${state.boards[0]?.name}". Set a default with: wadah config --default-board "<name>"`))
 
       const boardBuckets = board ? state.buckets.filter((b) => b.boardId === board.id) : state.buckets
@@ -871,8 +987,10 @@ program
           bucketId:     bucket?.id,
           boardId:      board?.id,
           assigneeId,
+          assigneeIds,
           requestedById,
           dueDate:      opts.due ? new Date(opts.due).getTime() : null,
+          priority:     opts.priority ?? null,
           repo:         opts.repo   ?? null,
           contextUrl:   opts.url    ?? null,
           notes:        opts.notes  ?? '',
@@ -897,7 +1015,8 @@ program
         } catch {}
       }
 
-      const assigneeName = state.assignees.find((a) => a.id === task.assigneeId)?.name ?? 'Unassigned'
+      const taskAssigneeNames = taskAssigneeIds(task).map((id) => state.assignees.find((a) => a.id === id)?.name ?? id)
+      const assigneeName = taskAssigneeNames.length ? taskAssigneeNames.join(', ') : 'Unassigned'
       console.log(chalk.green('\n✓ Created') + `  ${chalk.bold(task.title)}`)
       console.log(chalk.gray(`  ID: ${task.id}  ·  Assigned to: ${assigneeName}\n`))
     } catch (err) { handleError(err) }
@@ -937,20 +1056,35 @@ program
 
 program
   .command('assign <id>')
-  .description('Reassign a task to another person or agent')
-  .requiredOption('--to <name>', 'Assignee name')
+  .description('Assign task assignees (set/add/remove)')
+  .requiredOption('--to <names>', 'Assignee name(s), comma-separated')
+  .option('--mode <mode>', 'set | add | remove (default: set)', 'set')
   .action(async (id, opts) => {
     try {
       const state = await getState()
-      const a     = findAssignee(state.assignees, opts.to)
-      if (!a) return fail(`Assignee not found: ${opts.to}`)
+      const mode = String(opts.mode || 'set').toLowerCase()
+      if (!['set', 'add', 'remove'].includes(mode)) return fail('--mode must be one of: set, add, remove')
+      const ids = resolveAssigneeIdsByNames(state.assignees, opts.to)
+      if (ids.length === 0) return fail('Provide at least one assignee in --to')
+      const currentTask = await api(`/api/tasks/${id}`)
+      const current = taskAssigneeIds(currentTask)
+      const nextIds = mode === 'set'
+        ? ids
+        : mode === 'add'
+          ? Array.from(new Set([...current, ...ids]))
+          : current.filter((x) => !ids.includes(x))
 
       const myId = await resolveMyAssigneeId(state)
-      const task  = await api(`/api/tasks/${id}`, {
+      const task = await api(`/api/tasks/${id}`, {
         method: 'PATCH',
-        body:   JSON.stringify({ assigneeId: a.id, requestedById: myId }),
+        body: JSON.stringify({
+          assigneeIds: nextIds,
+          assigneeId: nextIds[0] ?? null,
+          requestedById: myId,
+        }),
       })
-      console.log(chalk.green('\n✓ Assigned') + `  ${chalk.bold(task.title)} → ${a.name}\n`)
+      const names = taskAssigneeIds(task).map((aid) => state.assignees.find((a) => a.id === aid)?.name ?? aid).join(', ') || 'Unassigned'
+      console.log(chalk.green('\n✓ Assigned') + `  ${chalk.bold(task.title)} → ${names}\n`)
     } catch (err) { handleError(err) }
   })
 
@@ -984,7 +1118,9 @@ program
   .option('--url <url>',              'Set issue/PR URL')
   .option('--due <YYYY-MM-DD>',       'Set due date')
   .option('--clear-due',              'Clear due date')
+  .option('--priority <level>',       'Set priority: urgent, high, medium, low (or clear)')
   .option('--assignee <name>',        'Set assignee')
+  .option('--assignees <names>',      'Set all assignees (comma-separated names)')
   .option('--board <name>',           'Set board')
   .option('--bucket <name>',          'Set bucket')
   .option('--completed <true|false>', 'Set completion state')
@@ -1002,6 +1138,12 @@ program
       if (opts.notes !== undefined) patch.notes = opts.notes
       if (opts.repo !== undefined) patch.repo = opts.repo
       if (opts.url !== undefined) patch.contextUrl = opts.url
+      if (opts.priority !== undefined) {
+        const VALID_PRIORITIES = ['urgent', 'high', 'medium', 'low', 'clear', 'none']
+        const p = opts.priority.toLowerCase()
+        if (!VALID_PRIORITIES.includes(p)) return fail(`Invalid priority. Use: urgent, high, medium, low (or "clear" to remove)`)
+        patch.priority = (p === 'clear' || p === 'none') ? null : p
+      }
 
       if (opts.due && opts.clearDue) {
         return fail('Use either --due or --clear-due, not both.')
@@ -1013,14 +1155,22 @@ program
       }
       if (opts.clearDue) patch.dueDate = null
 
-      const needsStateLookup = !!(opts.assignee || opts.board || opts.bucket)
+      const needsStateLookup = !!(opts.assignee || opts.assignees || opts.board || opts.bucket)
       const state = needsStateLookup ? await getState() : null
 
-
+      if (opts.assignee && opts.assignees) {
+        return fail('Use either --assignee or --assignees, not both.')
+      }
       if (opts.assignee) {
         const a = findAssignee(state.assignees, opts.assignee)
         if (!a) return fail(`Assignee not found: ${opts.assignee}`)
         patch.assigneeId = a.id
+        patch.assigneeIds = [a.id]
+      }
+      if (opts.assignees) {
+        const ids = resolveAssigneeIdsByNames(state.assignees, opts.assignees)
+        patch.assigneeIds = ids
+        patch.assigneeId = ids[0] ?? null
       }
       if (opts.board) {
         const b = findBoard(state.boards, opts.board)
@@ -1087,7 +1237,9 @@ program
   .action(async (id) => {
     try {
       const [task, state] = await Promise.all([api(`/api/tasks/${id}`), api('/api/state')])
-      const assignee  = state.assignees.find((a) => a.id === task.assigneeId)?.name  ?? 'Unassigned'
+      const assignee = taskAssigneeIds(task)
+        .map((id) => state.assignees.find((a) => a.id === id)?.name ?? id)
+        .join(', ') || 'Unassigned'
       const requester = state.assignees.find((a) => a.id === task.requestedById)?.name ?? null
       const bucket    = state.buckets.find((b)   => b.id === task.bucketId)?.title    ?? '—'
       const board     = state.boards.find((b)    => b.id === task.boardId)?.name      ?? '—'
@@ -1147,6 +1299,87 @@ program
     } catch (err) { handleError(err) }
   })
 
+const subtaskCmd = program.command('subtask').description('Manage task subtasks')
+
+subtaskCmd
+  .command('list <taskId>')
+  .description('List subtasks on a task')
+  .action(async (taskId) => {
+    try {
+      const task = await api(`/api/tasks/${taskId}`)
+      const subtasks = task.subtasks ?? []
+      if (isMachineOutput()) {
+        console.log(JSON.stringify({ taskId, subtasks }, null, runtimeJsonOutput ? 2 : 0))
+        return
+      }
+      console.log()
+      if (subtasks.length === 0) {
+        console.log(chalk.gray('  No subtasks.\n'))
+        return
+      }
+      console.log(chalk.bold(task.title))
+      subtasks.forEach((s) => {
+        const status = s.completed ? chalk.green('✓') : '○'
+        console.log(`  ${status}  ${s.title}  ${chalk.gray(s.id.slice(0, 8))}`)
+      })
+      console.log()
+    } catch (err) { handleError(err) }
+  })
+
+subtaskCmd
+  .command('add <taskId> <title>')
+  .description('Add a subtask to a task')
+  .action(async (taskId, title) => {
+    try {
+      const trimmedTitle = String(title ?? '').trim()
+      if (!trimmedTitle) return fail('Subtask title is required')
+      const task = await api(`/api/tasks/${taskId}`)
+      const nextSubtask = { id: randomUUID(), title: trimmedTitle, completed: false }
+      await api(`/api/tasks/${taskId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ subtasks: [...(task.subtasks ?? []), nextSubtask] }),
+      })
+      console.log(chalk.green('\n✓ Subtask added') + `  ${chalk.bold(nextSubtask.title)} ${chalk.gray(`(${nextSubtask.id.slice(0, 8)})`)}\n`)
+    } catch (err) { handleError(err) }
+  })
+
+subtaskCmd
+  .command('toggle <taskId> <subtaskId>')
+  .description('Toggle subtask completion')
+  .action(async (taskId, subtaskId) => {
+    try {
+      const task = await api(`/api/tasks/${taskId}`)
+      const subtasks = task.subtasks ?? []
+      const target = findSubtask(subtasks, subtaskId)
+      if (!target) return fail(`Subtask not found: ${subtaskId}`)
+      const nextSubtasks = subtasks.map((s) => s.id === target.id ? { ...s, completed: !s.completed } : s)
+      await api(`/api/tasks/${taskId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ subtasks: nextSubtasks }),
+      })
+      const marker = !target.completed ? chalk.green('✓') : '○'
+      console.log(chalk.green('\n✓ Subtask updated') + `  ${marker} ${chalk.bold(target.title)}\n`)
+    } catch (err) { handleError(err) }
+  })
+
+subtaskCmd
+  .command('delete <taskId> <subtaskId>')
+  .description('Delete a subtask from a task')
+  .action(async (taskId, subtaskId) => {
+    try {
+      const task = await api(`/api/tasks/${taskId}`)
+      const subtasks = task.subtasks ?? []
+      const target = findSubtask(subtasks, subtaskId)
+      if (!target) return fail(`Subtask not found: ${subtaskId}`)
+      const nextSubtasks = subtasks.filter((s) => s.id !== target.id)
+      await api(`/api/tasks/${taskId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ subtasks: nextSubtasks }),
+      })
+      console.log(chalk.green('\n✓ Subtask deleted') + `  ${chalk.bold(target.title)}\n`)
+    } catch (err) { handleError(err) }
+  })
+
 // ── tm boards ─────────────────────────────────────────────────────────────────
 
 program
@@ -1215,16 +1448,16 @@ program
           id:        a.id,
           name:      a.name,
           type:      a.type ?? 'human',
-          openCount: state.tasks.filter((t) => t.assigneeId === a.id && !t.completed).length,
-          doneCount: state.tasks.filter((t) => t.assigneeId === a.id &&  t.completed).length,
+          openCount: state.tasks.filter((t) => taskHasAssignee(t, a.id) && !t.completed).length,
+          doneCount: state.tasks.filter((t) => taskHasAssignee(t, a.id) &&  t.completed).length,
         }))
         console.log(JSON.stringify(result, null, runtimeJsonOutput ? 2 : 0))
         return
       }
       console.log()
       state.assignees.forEach((a) => {
-        const open = state.tasks.filter((t) => t.assigneeId === a.id && !t.completed).length
-        const done = state.tasks.filter((t) => t.assigneeId === a.id &&  t.completed).length
+        const open = state.tasks.filter((t) => taskHasAssignee(t, a.id) && !t.completed).length
+        const done = state.tasks.filter((t) => taskHasAssignee(t, a.id) &&  t.completed).length
         console.log(`  ${chalk.bold(a.name)}  ${chalk.gray(`${a.type ?? 'human'} · ${open} open · ${done} done`)}`)
       })
       console.log()
@@ -1249,6 +1482,29 @@ boardCmd
     } catch (err) { handleError(err) }
   })
 
+boardCmd
+  .command('rename <id> <name>')
+  .description('Rename a board')
+  .action(async (id, name) => {
+    try {
+      const payload = JSON.stringify({ name: String(name).trim() })
+      let board
+      try {
+        board = await api(`/api/boards/${id}`, { method: 'PATCH', body: payload })
+      } catch (err) {
+        // Backward compatibility: some deployments only support PUT for board rename.
+        const notFound = err instanceof CliError && err.code === 'api_error' && String(err.message).toLowerCase().includes('not found')
+        if (!notFound) throw err
+        board = await api(`/api/boards/${id}`, { method: 'PUT', body: payload })
+      }
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(board, null, runtimeJsonOutput ? 2 : 0))
+      } else {
+        console.log(chalk.green('\n✓ Board renamed') + `  ${chalk.bold(board.name)}  ${chalk.gray(board.id?.slice(0, 8))}\n`)
+      }
+    } catch (err) { handleError(err) }
+  })
+
 boardCmd
   .command('delete <id>')
   .description('Delete a board (cannot delete the last one)')
@@ -1418,6 +1674,158 @@ program
     } catch (err) { handleError(err) }
   })
 
+program
+  .command('repos')
+  .description('List linked GitHub repositories')
+  .action(async () => {
+    try {
+      const list = await api('/api/github-repos').catch(() => [])
+      const arr = Array.isArray(list) ? list : []
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(arr, null, runtimeJsonOutput ? 2 : 0))
+      } else if (arr.length === 0) {
+        console.log(chalk.gray('\nNo linked repositories. Add one: wadah repo add https://github.com/owner/repo\n'))
+      } else {
+        console.log()
+        arr.forEach((r) => {
+          const full = r.fullName ?? `${r.owner}/${r.name}`
+          console.log(`  ${chalk.bold(full)}  ${chalk.gray(`id: ${r.id?.slice(0, 8)}`)}`)
+          console.log(chalk.gray(`    ${r.url}`))
+        })
+        console.log()
+      }
+    } catch (err) { handleError(err) }
+  })
+
+const repoCmd = program.command('repo').description('Link and manage GitHub repositories')
+
+repoCmd
+  .command('add <repo>')
+  .description('Link a GitHub repo (URL or owner/repo)')
+  .action(async (repoInput) => {
+    try {
+      const parsed = parseGitHubRepoInput(repoInput)
+      if (!parsed) return fail('Provide a valid GitHub repo URL or owner/repo')
+      const linked = await api('/api/github-repos', {
+        method: 'POST',
+        body: JSON.stringify({ url: parsed.url }),
+      })
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(linked, null, runtimeJsonOutput ? 2 : 0))
+      } else {
+        const full = linked.fullName ?? `${linked.owner}/${linked.name}`
+        console.log(chalk.green('\n✓ Repo linked') + `  ${chalk.bold(full)}`)
+        console.log(chalk.gray(`  ${linked.url}\n`))
+      }
+    } catch (err) { handleError(err) }
+  })
+
+repoCmd
+  .command('list')
+  .description('List linked GitHub repositories')
+  .action(async () => {
+    try {
+      const list = await api('/api/github-repos').catch(() => [])
+      const arr = Array.isArray(list) ? list : []
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(arr, null, runtimeJsonOutput ? 2 : 0))
+      } else if (arr.length === 0) {
+        console.log(chalk.gray('\nNo linked repositories. Add one: wadah repo add https://github.com/owner/repo\n'))
+      } else {
+        console.log()
+        arr.forEach((r) => {
+          const full = r.fullName ?? `${r.owner}/${r.name}`
+          console.log(`  ${chalk.bold(full)}  ${chalk.gray(`id: ${r.id?.slice(0, 8)}`)}`)
+          console.log(chalk.gray(`    ${r.url}`))
+        })
+        console.log()
+      }
+    } catch (err) { handleError(err) }
+  })
+
+repoCmd
+  .command('remove <id>')
+  .description('Unlink a repository by id (use: wadah repos)')
+  .action(async (id) => {
+    try {
+      await api(`/api/github-repos/${encodeURIComponent(id)}`, { method: 'DELETE' })
+      if (!runtimeQuietOutput) console.log(chalk.green('\n✓ Repo unlinked\n'))
+    } catch (err) { handleError(err) }
+  })
+
+const prCmd = program.command('pr').description('Attach and open pull requests on tasks')
+
+prCmd
+  .command('link <taskId> <prUrl>')
+  .description('Attach a PR URL to a task')
+  .option('--comment', 'Add a task comment with the PR link')
+  .action(async function (taskId, prUrl) {
+    const opts = this.opts()
+    try {
+      let parsed
+      try {
+        parsed = new URL(String(prUrl).trim())
+      } catch {
+        return fail('Provide a valid PR URL (e.g. https://github.com/owner/repo/pull/123)')
+      }
+      if (!['http:', 'https:'].includes(parsed.protocol)) {
+        return fail('PR URL must start with http:// or https://')
+      }
+      const normalizedUrl = parsed.toString()
+
+      const task = await api(`/api/tasks/${taskId}`)
+      await api(`/api/tasks/${taskId}`, {
+        method: 'PATCH',
+        body: JSON.stringify({ contextUrl: normalizedUrl }),
+      })
+      if (opts.comment) {
+        const comment = {
+          id: randomUUID(),
+          text: `Linked PR: ${normalizedUrl}`,
+          createdAt: Date.now(),
+        }
+        await api(`/api/tasks/${taskId}`, {
+          method: 'PATCH',
+          body: JSON.stringify({ comments: [...(task.comments ?? []), comment] }),
+        })
+      }
+
+      if (isMachineOutput()) {
+        console.log(JSON.stringify({ taskId, prUrl: normalizedUrl, linked: true, commented: Boolean(opts.comment) }, null, runtimeJsonOutput ? 2 : 0))
+      } else {
+        console.log(chalk.green('\n✓ PR linked') + `  ${chalk.bold(task.title)}`)
+        console.log(chalk.gray(`  ${normalizedUrl}${opts.comment ? '  ·  comment added' : ''}\n`))
+      }
+    } catch (err) { handleError(err) }
+  })
+
+prCmd
+  .command('open <taskId>')
+  .description('Open the linked PR URL for a task')
+  .option('--no-browser', "Don't auto-open browser; print URL only")
+  .action(async function (taskId) {
+    const opts = this.opts()
+    try {
+      const task = await api(`/api/tasks/${taskId}`)
+      const url = task?.contextUrl ? String(task.contextUrl).trim() : ''
+      if (!url) return fail('This task has no linked PR URL. Use: wadah pr link <task-id> <pr-url>')
+
+      if (isMachineOutput()) {
+        console.log(JSON.stringify({ taskId, prUrl: url }, null, runtimeJsonOutput ? 2 : 0))
+        return
+      }
+
+      console.log(chalk.gray(`\nPR: ${url}`))
+      if (opts.browser) {
+        const opened = await openBrowser(url)
+        if (opened) console.log(chalk.green('✓ Opened in browser\n'))
+        else console.log(chalk.yellow('Could not open browser automatically. Open the URL manually.\n'))
+      } else {
+        console.log()
+      }
+    } catch (err) { handleError(err) }
+  })
+
 // ── agent tokens ──────────────────────────────────────────────────────────────
 
 program
@@ -1434,8 +1842,12 @@ program
       } else {
         console.log()
         arr.forEach((t) => {
-          const as = t.assigneeName ? chalk.gray(` · acts as ${t.assigneeName}`) : ''
-          console.log(`  ${chalk.bold(t.name)}  ${chalk.gray(`id: ${t.id?.slice(0, 8)}${as}`)}`)
+          const as      = t.assigneeName ? ` · ${chalk.cyan(t.assigneeName)}` : ''
+          const creator = t.createdBy    ? chalk.gray(` · created by ${t.createdBy}`) : ''
+          const used    = t.last_used_at ? chalk.gray(` · last used ${new Date(t.last_used_at).toLocaleDateString()}`) : chalk.gray(' · never used')
+          const usage   = t.usageLast30d > 0 ? chalk.gray(` · ${t.usageLast30d} call${t.usageLast30d === 1 ? '' : 's'} (30d)`) : ''
+          console.log(`  ${chalk.bold(t.name)}${as}`)
+          console.log(chalk.gray(`    id: ${t.id?.slice(0, 8)}${used}${usage}${creator}`))
         })
         console.log()
       }
@@ -1461,9 +1873,12 @@ agentTokenCmd
       } else {
         console.log(chalk.green('\n✓ Agent token created'))
         console.log(chalk.gray(`  Name: ${result.name}  Id: ${result.id?.slice(0, 8)}  Acts as: ${result.assigneeName ?? result.name}`))
-        console.log(chalk.yellow('\n  Token (save it — shown once):'))
+        console.log(chalk.yellow('\n  Token (store it now — shown once):'))
         console.log(`  ${result.token}`)
-        console.log(chalk.gray('\n  Use: export TASK_MANAGER_TOKEN="<token>"\n'))
+        console.log(chalk.gray('\n  Store it so you don’t lose it:'))
+        console.log(chalk.gray('  · GitHub Actions: Repo → Settings → Secrets and variables → Actions → New secret → TASK_MANAGER_TOKEN'))
+        console.log(chalk.gray('  · Cursor: Settings → Environment variables → TASK_MANAGER_TOKEN'))
+        console.log(chalk.gray('  · Shell: export TASK_MANAGER_TOKEN="<paste token here>"\n'))
       }
     } catch (err) { handleError(err) }
   })
@@ -1478,6 +1893,32 @@ agentTokenCmd
     } catch (err) { handleError(err) }
   })
 
+agentTokenCmd
+  .command('events <id>')
+  .description('Show audit events for an agent token (created / used / deleted)')
+  .action(async (id) => {
+    try {
+      const events = await api(`/api/agent-tokens/${id}/events`)
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(events, null, runtimeJsonOutput ? 2 : 0))
+        return
+      }
+      if (!events?.length) {
+        console.log(chalk.gray('\nNo events recorded for this token.\n'))
+        return
+      }
+      console.log()
+      events.forEach((e) => {
+        const when = new Date(e.created_at).toLocaleString()
+        const ep   = e.endpoint ? chalk.gray(` ${e.endpoint}`) : ''
+        const ip   = e.ip_address ? chalk.gray(` from ${e.ip_address}`) : ''
+        const mark = e.event_type === 'created' ? chalk.green('●') : e.event_type === 'deleted' ? chalk.red('●') : chalk.blue('●')
+        console.log(`  ${mark} ${chalk.bold(e.event_type.padEnd(8))} ${chalk.gray(when)}${ep}${ip}`)
+      })
+      console.log()
+    } catch (err) { handleError(err) }
+  })
+
 // ── calendar events ──────────────────────────────────────────────────────────
 
 const calendarCmd = program
@@ -1766,17 +2207,23 @@ program
     if (!hasEnvToken && !hasSavedToken) {
       addCheck('auth_token', 'warn', 'No token available. Run wadah login.')
     } else if (hasEnvToken) {
-      addCheck('auth_token', 'pass', 'Using token from env/flag')
+      addCheck('auth_token', 'pass', 'Using agent token from env/flag (TASK_MANAGER_TOKEN)')
     } else {
       addCheck('auth_token', 'pass', 'Using token from profile config')
     }
 
     if (pingOk) {
+      let meBody = null
       try {
         const meRes = await fetch(`${getApiBase()}/api/auth/me`, { headers: authHeaders() })
         if (meRes.ok) {
-          const meBody = await meRes.json().catch(() => ({}))
-          addCheck('auth_me', 'pass', `Authenticated as ${meBody.user?.email ?? 'unknown user'}`)
+          meBody = await meRes.json().catch(() => ({}))
+          const isAgent = meBody.workspaces?.[0]?.role === 'agent'
+          if (isAgent) {
+            addCheck('auth_me', 'pass', `Authenticated as agent (workspace: ${meBody.workspaces?.[0]?.name ?? '?'})`)
+          } else {
+            addCheck('auth_me', 'pass', `Authenticated as ${meBody.user?.email ?? 'unknown user'}`)
+          }
         } else if (meRes.status === 401) {
           addCheck('auth_me', 'warn', 'Token is missing/expired. Run wadah login.')
         } else {
@@ -1786,6 +2233,41 @@ program
         addCheck('auth_me', 'warn', `Auth check failed: ${err.message}`)
       }
 
+      // Agent-specific checks (only when TASK_MANAGER_TOKEN is set)
+      if (hasEnvToken && meBody) {
+        const isAgent = meBody.workspaces?.[0]?.role === 'agent'
+        if (!isAgent) {
+          addCheck('agent_identity', 'warn', 'Token is not an agent token — it authenticated as a human user')
+        } else {
+          addCheck('agent_identity', 'pass', `Token resolves to agent role`)
+
+          if (meBody.assigneeId) {
+            addCheck('agent_assignee', 'pass', `Assignee: ${meBody.assigneeName ?? meBody.assigneeId}`)
+          } else {
+            addCheck('agent_assignee', 'fail', 'No assignee linked to this token. Create a new token via the app (Agent tokens) so it auto-creates an assignee.')
+          }
+
+          const defaultBoard = confGet('default_board')
+          if (!defaultBoard) {
+            addCheck('agent_default_board', 'warn', 'No default board set — wadah add will guess. Fix: wadah config --default-board "<name>"')
+          } else {
+            // Verify board exists
+            try {
+              const state = await getState()
+              const board = state.boards.find((b) => b.name.toLowerCase().includes(defaultBoard.toLowerCase()))
+              if (board) {
+                const buckets = state.buckets.filter((b) => b.boardId === board.id)
+                addCheck('agent_default_board', 'pass', `Default board: "${board.name}" (${buckets.length} bucket${buckets.length === 1 ? '' : 's'})`)
+              } else {
+                addCheck('agent_default_board', 'fail', `Default board "${defaultBoard}" not found. Update: wadah config --default-board "<name>"`)
+              }
+            } catch {
+              addCheck('agent_default_board', 'warn', `Could not verify default board "${defaultBoard}"`)
+            }
+          }
+        }
+      }
+
       try {
         const deviceRes = await fetch(`${getApiBase()}/api/auth/device/start`, {
           method: 'POST',
@@ -1861,17 +2343,25 @@ program
   .command('config')
   .description('Show or set CLI configuration')
   .option('--api-url <url>', 'Set API base URL')
+  .option('--default-board <name>', 'Set default board for wadah add (agents: avoids landing tasks on wrong board)')
   .action((opts) => {
     if (opts.apiUrl) {
       confSet('api_url', opts.apiUrl.trim().replace(/\/$/, ''))
       if (!runtimeQuietOutput) console.log(chalk.green(`\n✓ API URL set to ${opts.apiUrl}\n`))
       return
     }
+    if (opts.defaultBoard) {
+      confSet('default_board', opts.defaultBoard.trim())
+      if (!runtimeQuietOutput) console.log(chalk.green(`\n✓ Default board set to "${opts.defaultBoard.trim()}"\n  wadah add will now use this board unless --board is specified.\n`))
+      return
+    }
+    const defaultBoard = confGet('default_board')
     const config = {
       api_url: getApiBase(),
       signed_in_as: confGet('user_email') ?? null,
       agent_mode: Boolean(process.env.TASK_MANAGER_TOKEN || runtimeToken),
       profile: getProfile(),
+      default_board: defaultBoard ?? null,
       config_file: conf.path,
     }
     if (isMachineOutput()) {
@@ -1880,23 +2370,378 @@ program
     }
     console.log()
     console.log(chalk.bold('CLI config'))
-    console.log(chalk.gray(`  API URL:      ${config.api_url}`))
-    console.log(chalk.gray(`  Signed in as: ${config.signed_in_as ?? '—'}`))
-    console.log(chalk.gray(`  Agent mode:   ${config.agent_mode ? 'yes (TASK_MANAGER_TOKEN set)' : 'no'}`))
-    console.log(chalk.gray(`  Profile:      ${getProfile()}`))
-    console.log(chalk.gray(`  Config file:  ${config.config_file}`))
+    console.log(chalk.gray(`  API URL:       ${config.api_url}`))
+    console.log(chalk.gray(`  Signed in as:  ${config.signed_in_as ?? '—'}`))
+    console.log(chalk.gray(`  Agent mode:    ${config.agent_mode ? 'yes (TASK_MANAGER_TOKEN set)' : 'no'}`))
+    console.log(chalk.gray(`  Default board: ${defaultBoard ?? '— (not set, use: wadah config --default-board "Name")'}`))
+    console.log(chalk.gray(`  Profile:       ${getProfile()}`))
+    console.log(chalk.gray(`  Config file:   ${config.config_file}`))
     console.log()
   })
 
+// ── wadah board-view ──────────────────────────────────────────────────────────
+
+program
+  .command('board-view')
+  .description('Show a structured view of a board grouped by bucket — lets agents verify task placement')
+  .option('--board <name>', 'Board name (defaults to current/default board)')
+  .option('--assignee <name>', 'Filter to tasks for a specific assignee')
+  .action(async (opts) => {
+    try {
+      const state = await getState()
+      const defaultBoardName = opts.board ?? confGet('default_board')
+      const board = defaultBoardName
+        ? state.boards.find((b) => b.name.toLowerCase().includes(defaultBoardName.toLowerCase()))
+        : state.boards.find((b) => b.id === state.currentBoardId) ?? state.boards[0]
+
+      if (!board) return fail(opts.board ? `Board not found: ${opts.board}` : 'No boards found')
+
+      const buckets = state.buckets
+        .filter((b) => b.boardId === board.id)
+        .sort((a, b) => a.order - b.order)
+
+      let tasks = state.tasks.filter((t) => t.boardId === board.id && !t.completed)
+      if (opts.assignee) {
+        const a = findAssignee(state.assignees, opts.assignee)
+        if (a) tasks = tasks.filter((t) => taskHasAssignee(t, a.id))
+      }
+
+      const view = {
+        board: { id: board.id, name: board.name },
+        buckets: buckets.map((bucket) => ({
+          id: bucket.id,
+          name: bucket.title,
+          tasks: tasks
+            .filter((t) => t.bucketId === bucket.id)
+            .sort((a, b) => a.order - b.order)
+            .map((t) => ({
+              id: t.id,
+              title: t.title,
+              assignee: taskAssigneeIds(t).map((aid) => state.assignees.find((a) => a.id === aid)?.name ?? aid).join(', ') || null,
+              priority: t.priority ?? null,
+            })),
+        })),
+      }
+
+      if (isMachineOutput()) {
+        console.log(JSON.stringify(view, null, runtimeJsonOutput ? 2 : 0))
+        return
+      }
+
+      console.log()
+      console.log(chalk.bold(`Board: ${board.name}`))
+      for (const bucket of view.buckets) {
+        console.log(chalk.gray(`\n  ${bucket.name} (${bucket.tasks.length})`))
+        if (bucket.tasks.length === 0) {
+          console.log(chalk.gray('    — empty'))
+        } else {
+          bucket.tasks.forEach((t) => {
+            const who = t.assignee ? chalk.gray(` @${t.assignee}`) : ''
+            console.log(`    ${t.id.slice(0, 8)}  ${t.title.slice(0, 60)}${who}`)
+          })
+        }
+      }
+      console.log()
+    } catch (err) { handleError(err) }
+  })
+
 // ── shell completion ──────────────────────────────────────────────────────────
 
 const CLI_COMMANDS = [
-  'add', 'agent-token', 'agent-tokens', 'assign', 'assignee', 'assignees', 'board', 'boards',
+  'add', 'agent-token', 'agent-tokens', 'assign', 'assignee', 'assignees', 'board', 'board-view', 'boards',
   'bucket', 'buckets', 'calendar', 'comment', 'complete', 'config', 'delete', 'doc', 'docs',
   'do', 'doctor', 'files', 'folder', 'folders', 'invite', 'list', 'login', 'members', 'mkdir',
-  'move', 'open', 'reopen', 'requested', 'search', 'signup', 'state', 'update', 'upload', 'view', 'whoami',
+  'forget', 'memory', 'memory-export', 'memory-log', 'move', 'open', 'pr', 'repo', 'repos', 'reopen', 'remember', 'requested', 'search', 'setup-agent', 'signup', 'state', 'update', 'upload', 'view', 'whoami',
 ]
 
+// ── wadah setup-agent ─────────────────────────────────────────────────────────
+
+program
+  .command('setup-agent')
+  .description('Interactive wizard: create an agent token, write it to your shell profile, and verify everything works')
+  .option('--name <name>', 'Agent name (skip prompt)')
+  .option('--board <board>', 'Default board name (skip prompt)')
+  .option('--skip-env', 'Skip writing TASK_MANAGER_TOKEN to shell profile (print instructions only)')
+  .action(async (opts) => {
+    const readline = await import('node:readline/promises')
+    const os = await import('node:os')
+    const fs = await import('node:fs')
+    const path = await import('node:path')
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    const ask = (q) => rl.question(q)
+
+    console.log()
+    console.log(chalk.bold('Open Wadah — Agent Setup Wizard'))
+    console.log(chalk.gray('  This wizard will create an agent token and configure your environment.\n'))
+
+    // Step 1: verify auth
+    console.log(chalk.bold('Step 1/5  Checking authentication…'))
+    let me
+    try {
+      me = await api('/api/auth/me')
+      if (me.workspaces?.[0]?.role === 'agent') {
+        console.log(chalk.yellow('  ⚠ You are currently authenticated as an agent, not a human user.'))
+        console.log(chalk.gray('    Run: wadah login  then rerun: wadah setup-agent\n'))
+        rl.close(); return
+      }
+      console.log(chalk.green(`  ✓ Signed in as ${me.user?.email ?? 'unknown'}`))
+    } catch {
+      console.log(chalk.red('  ✗ Not authenticated. Run: wadah login'))
+      console.log(chalk.gray('  Then rerun: wadah setup-agent\n'))
+      rl.close(); return
+    }
+
+    // Step 2: agent name
+    console.log()
+    console.log(chalk.bold('Step 2/5  Name your agent'))
+    let agentName = opts.name
+    if (!agentName) {
+      agentName = (await ask(chalk.gray('  What should your agent be called? (e.g. "Cursor", "Claude") > '))).trim()
+    } else {
+      console.log(chalk.gray(`  Using: ${agentName}`))
+    }
+    if (!agentName) agentName = 'My Agent'
+
+    // Step 3: create token
+    console.log()
+    console.log(chalk.bold('Step 3/5  Creating agent token…'))
+    let tokenResult
+    try {
+      tokenResult = await api('/api/agent-tokens', {
+        method: 'POST',
+        body: JSON.stringify({ name: agentName, assigneeName: agentName }),
+      })
+      console.log(chalk.green(`  ✓ Token created  (assignee: ${tokenResult.assigneeName ?? agentName})`))
+    } catch (err) {
+      console.log(chalk.red(`  ✗ Failed to create token: ${err.message}`))
+      rl.close(); return
+    }
+
+    const rawToken = tokenResult.token
+    console.log()
+    console.log(chalk.yellow('  Token (shown once — copy it now):'))
+    console.log(`  ${chalk.bold(rawToken)}`)
+
+    // Step 4: write env var to shell profile
+    console.log()
+    console.log(chalk.bold('Step 4/5  Setting up TASK_MANAGER_TOKEN…'))
+
+    const shell = process.env.SHELL ?? ''
+    const profileMap = { zsh: '.zshrc', bash: '.bashrc', fish: '.config/fish/config.fish' }
+    const profileKey = Object.keys(profileMap).find((k) => shell.includes(k))
+    const profileFile = profileKey ? path.join(os.homedir(), profileMap[profileKey]) : null
+    const marker = '# added by wadah setup-agent'
+    const exportLine = `\nexport TASK_MANAGER_TOKEN="${rawToken}"  ${marker}\n`
+
+    if (opts.skipEnv || !profileFile) {
+      console.log(chalk.gray('  Skipping automatic profile write. Add this line manually:'))
+      console.log(chalk.gray(`  export TASK_MANAGER_TOKEN="${rawToken}"`))
+      const rcGuess = shell.includes('zsh') ? '~/.zshrc' : shell.includes('fish') ? '~/.config/fish/config.fish' : '~/.bashrc'
+      console.log(chalk.gray(`  Then reload: source ${rcGuess}`))
+    } else {
+      const confirm = await ask(chalk.gray(`  Write to ${profileFile}? (Y/n) > `))
+      if (confirm.trim().toLowerCase() !== 'n') {
+        try {
+          const existing = fs.existsSync(profileFile) ? fs.readFileSync(profileFile, 'utf8') : ''
+          const filtered = existing
+            .split('\n')
+            .filter((line) => !line.includes('TASK_MANAGER_TOKEN=') && !line.includes(marker))
+            .join('\n')
+          const next = `${filtered.trimEnd()}${exportLine}`
+          fs.writeFileSync(profileFile, `${next.endsWith('\n') ? next : `${next}\n`}`)
+          console.log(chalk.green(`  ✓ Written to ${profileFile}`))
+          console.log(chalk.gray(`  Reload now: source ${profileFile}`))
+        } catch (e) {
+          console.log(chalk.yellow(`  ⚠ Could not write to ${profileFile}: ${e.message}`))
+          console.log(chalk.gray(`  Add manually: export TASK_MANAGER_TOKEN="${rawToken}"`))
+        }
+      } else {
+        console.log(chalk.gray(`  Skipped. Add manually: export TASK_MANAGER_TOKEN="${rawToken}"`))
+      }
+    }
+
+    // Step 4.5: verify the created token works (without requiring shell reload)
+    console.log()
+    console.log(chalk.bold('Step 4.5/5  Verifying token…'))
+    try {
+      const verifyRes = await fetch(`${getApiBase()}/api/auth/me`, {
+        headers: { Authorization: `Bearer ${rawToken}`, 'Content-Type': 'application/json' },
+      })
+      if (!verifyRes.ok) {
+        console.log(chalk.yellow(`  ⚠ Token verification returned ${verifyRes.status}. Continue and run: wadah doctor`))
+      } else {
+        const verifyBody = await verifyRes.json().catch(() => ({}))
+        const role = verifyBody?.workspaces?.[0]?.role ?? '?'
+        const actsAs = verifyBody?.assigneeName ?? tokenResult.assigneeName ?? agentName
+        console.log(chalk.green(`  ✓ Token valid (role: ${role}, assignee: ${actsAs})`))
+      }
+    } catch (e) {
+      console.log(chalk.yellow(`  ⚠ Could not verify token now: ${e.message}`))
+    }
+
+    // Step 5: default board
+    console.log()
+    console.log(chalk.bold('Step 5/5  Default board'))
+    let boardName = opts.board
+    if (!boardName) {
+      try {
+        const state = await getState()
+        if (state.boards?.length > 0) {
+          console.log(chalk.gray('  Available boards:'))
+          state.boards.forEach((b, i) => console.log(chalk.gray(`    ${i + 1}. ${b.name}`)))
+          const boardInput = (await ask(chalk.gray('  Which board should new tasks land on by default? (name or number, Enter to skip) > '))).trim()
+          if (boardInput) {
+            const byNum = parseInt(boardInput, 10)
+            const picked = !isNaN(byNum) ? state.boards[byNum - 1] : state.boards.find((b) => b.name.toLowerCase().includes(boardInput.toLowerCase()))
+            if (picked) {
+              confSet('default_board', picked.name)
+              boardName = picked.name
+              console.log(chalk.green(`  ✓ Default board: "${picked.name}"`))
+            } else {
+              console.log(chalk.yellow(`  ⚠ Board not found — skipping. Set later: wadah config --default-board "<name>"`))
+            }
+          } else {
+            console.log(chalk.gray('  Skipped. Set later: wadah config --default-board "<name>"'))
+          }
+        }
+      } catch { /* board step is optional */ }
+    } else {
+      confSet('default_board', boardName)
+      console.log(chalk.green(`  ✓ Default board: "${boardName}"`))
+    }
+
+    rl.close()
+
+    console.log()
+    console.log(chalk.bold.green('✓ Setup complete!'))
+    console.log()
+    console.log(chalk.gray('  Next steps:'))
+    console.log(chalk.gray(`  1. Reload your shell profile (or open a new terminal)`))
+    console.log(chalk.gray(`  2. Verify everything works: wadah doctor`))
+    console.log(chalk.gray(`  3. Create your first task: wadah add "My first task"`))
+    console.log()
+  })
+
+// ── agent memory ─────────────────────────────────────────────────────────────
+
+program
+  .command('memory')
+  .description('Show all memory for this agent, grouped by category')
+  .option('--category <cat>', 'Filter to a specific category')
+  .option('--log', 'Show memory change history instead of current values')
+  .option('--export', 'Export all memory as a JSON blob (for backup or handoff)')
+  .action(async (opts) => {
+    try {
+      if (opts.export) {
+        const data = await api('/api/agent-memory/export')
+        console.log(JSON.stringify(data, null, runtimeJsonOutput ? 2 : 0))
+        return
+      }
+      if (opts.log) {
+        const log = await api('/api/agent-memory/log')
+        if (isMachineOutput()) { console.log(JSON.stringify(log, null, runtimeJsonOutput ? 2 : 0)); return }
+        if (!log?.length) { console.log(chalk.gray('\nNo memory changes recorded yet.\n')); return }
+        console.log()
+        log.forEach((e) => {
+          const when = new Date(e.changed_at).toLocaleString()
+          const key  = e.agent_memory?.key ?? '?'
+          console.log(`  ${chalk.gray(when)}  ${chalk.bold(key)}`)
+          if (e.old_value !== null) console.log(chalk.gray(`    was: ${String(e.old_value).slice(0, 80)}`))
+          console.log(chalk.gray(`    now: ${String(e.new_value).slice(0, 80)}`))
+        })
+        console.log()
+        return
+      }
+
+      const url = opts.category ? `/api/agent-memory?category=${encodeURIComponent(opts.category)}` : '/api/agent-memory'
+      const entries = await api(url)
+      if (isMachineOutput()) { console.log(JSON.stringify(entries, null, runtimeJsonOutput ? 2 : 0)); return }
+      if (!entries?.length) { console.log(chalk.gray('\nNo memory stored yet. Use: wadah remember <key> <value>\n')); return }
+
+      console.log()
+      const byCategory = {}
+      entries.forEach((e) => {
+        const cat = e.category ?? 'general'
+        if (!byCategory[cat]) byCategory[cat] = []
+        byCategory[cat].push(e)
+      })
+      for (const [cat, items] of Object.entries(byCategory)) {
+        console.log(chalk.bold(`${cat.charAt(0).toUpperCase() + cat.slice(1)}`))
+        items.forEach((e) => {
+          const conf = e.confidence < 1 ? chalk.yellow(` (${Math.round(e.confidence * 100)}% confidence)`) : ''
+          const val  = String(e.value).slice(0, 80)
+          console.log(`  ${e.key.padEnd(28)} ${val}${conf}`)
+        })
+        console.log()
+      }
+    } catch (err) { handleError(err) }
+  })
+
+program
+  .command('remember <key> <value>')
+  .description('Write or update a memory entry for this agent')
+  .option('--category <cat>', 'Category (config, preferences, workspace, session, learned)', 'general')
+  .option('--confidence <0-1>', 'Confidence level (default 1.0)', '1.0')
+  .option('--source <text>', 'How this was learned (e.g. user_confirmed, inferred)')
+  .option('--session <id>', 'Session identifier for audit log')
+  .action(async (key, value, opts) => {
+    try {
+      const body = {
+        value,
+        category:   opts.category,
+        confidence: parseFloat(opts.confidence || '1'),
+        source:     opts.source ?? null,
+        sessionId:  opts.session ?? null,
+      }
+      const result = await api(`/api/agent-memory/${encodeURIComponent(key)}`, { method: 'PUT', body: JSON.stringify(body) })
+      if (isMachineOutput()) { console.log(JSON.stringify(result, null, runtimeJsonOutput ? 2 : 0)); return }
+      console.log(chalk.green(`\n✓ Remembered  ${chalk.bold(key)} = ${value}\n`))
+    } catch (err) { handleError(err) }
+  })
+
+program
+  .command('forget <key>')
+  .description('Delete a memory entry')
+  .action(async (key) => {
+    try {
+      await api(`/api/agent-memory/${encodeURIComponent(key)}`, { method: 'DELETE' })
+      if (!runtimeQuietOutput) console.log(chalk.green(`\n✓ Forgotten  ${key}\n`))
+    } catch (err) { handleError(err) }
+  })
+
+program
+  .command('memory-log')
+  .description('Alias for: wadah memory --log')
+  .action(async () => {
+    try {
+      const log = await api('/api/agent-memory/log')
+      if (isMachineOutput()) { console.log(JSON.stringify(log, null, runtimeJsonOutput ? 2 : 0)); return }
+      if (!log?.length) { console.log(chalk.gray('\nNo memory changes recorded yet.\n')); return }
+      console.log()
+      log.forEach((e) => {
+        const when = new Date(e.changed_at).toLocaleString()
+        const key  = e.agent_memory?.key ?? '?'
+        console.log(`  ${chalk.gray(when)}  ${chalk.bold(key)}`)
+        if (e.old_value !== null) console.log(chalk.gray(`    was: ${String(e.old_value).slice(0, 80)}`))
+        console.log(chalk.gray(`    now: ${String(e.new_value).slice(0, 80)}`))
+      })
+      console.log()
+    } catch (err) { handleError(err) }
+  })
+
+program
+  .command('memory-export')
+  .description('Alias for: wadah memory --export')
+  .action(async () => {
+    try {
+      const data = await api('/api/agent-memory/export')
+      console.log(JSON.stringify(data, null, runtimeJsonOutput ? 2 : 0))
+    } catch (err) { handleError(err) }
+  })
+
+// ── shell completion ──────────────────────────────────────────────────────────
+
 program
   .command('completion [shell]')
   .description('Print shell completion script (bash or zsh). Add to your profile: wadah completion bash >> ~/.bashrc')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-wadah",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Open Wadah CLI — shared task board for humans and agents",
   "type": "module",
   "bin": {
@@ -13,10 +13,10 @@
     "test": "node --test test/cli.test.js"
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.3.0",
+    "@inquirer/prompts": "^8.3.2",
     "chalk": "^5.4.1",
-    "commander": "^13.1.0",
-    "conf": "^13.1.0",
+    "commander": "^14.0.3",
+    "conf": "^15.1.0",
     "form-data": "^4.0.0",
     "node-fetch": "^3.3.2"
   }