@damper/cli 0.6.11 → 0.6.13

package/dist/commands/cleanup.js

@@ -5,6 +5,7 @@ import pc from 'picocolors';
 import { getWorktrees, cleanupStaleWorktrees, removeWorktree } from '../services/state.js';
 import { createDamperApi } from '../services/damper-api.js';
 import { removeWorktreeDir } from '../services/worktree.js';
+import { shortId, shortIdRaw, formatTaskLine } from '../ui/format.js';
 async function hasUncommittedChanges(worktreePath) {
     try {
         const { stdout } = await execa('git', ['status', '--porcelain'], {
@@ -108,10 +109,7 @@ export async function cleanupCommand() {
     console.log(pc.bold('\nWorktrees available for cleanup:\n'));
     const choices = candidates.map(c => {
         const worktreeName = c.worktree.path.split('/').pop() || c.worktree.path;
-        let description = `#${c.worktree.taskId}`;
-        if (c.task) {
-            description += ` - ${c.task.title}`;
-        }
+        let description = c.task ? formatTaskLine(c.task) : shortId(c.worktree.taskId);
         let reasonBadge = '';
         switch (c.reason) {
             case 'completed':
@@ -177,7 +175,7 @@ export async function cleanupCommand() {
             if (candidate.reason === 'in_progress' && api) {
                 try {
                     await api.abandonTask(worktree.taskId, 'Dropped via CLI cleanup');
-                    console.log(pc.green(`✓ Released task #${worktree.taskId}`));
+                    console.log(pc.green(`✓ Released task #${shortIdRaw(worktree.taskId)}`));
                 }
                 catch (err) {
                     const error = err;

package/dist/commands/release.js

@@ -4,6 +4,7 @@ import { createDamperApi } from '../services/damper-api.js';
 import { getWorktrees, removeWorktree } from '../services/state.js';
 import { removeWorktreeDir, getGitRoot } from '../services/worktree.js';
 import { getApiKey } from '../services/config.js';
+import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort } from '../ui/format.js';
 export async function releaseCommand() {
     // Get project root
     let projectRoot;
@@ -34,10 +35,14 @@ export async function releaseCommand() {
     const worktrees = getWorktrees();
     const choices = tasks.map(task => {
         const worktree = worktrees.find(w => w.taskId === task.id);
+        const priorityIcon = getPriorityIcon(task.priority);
+        const typeIcon = getTypeIcon(task.type);
+        const id = shortId(task.id);
+        const effort = formatEffort(task.effort);
         const lockedInfo = task.lockedBy ? pc.dim(` (locked by ${task.lockedBy})`) : '';
         const worktreeInfo = worktree ? pc.dim(` [has worktree]`) : '';
         return {
-            name: `#${task.id} ${task.title}${lockedInfo}${worktreeInfo}`,
+            name: `${priorityIcon}${typeIcon} ${id}  ${task.title}${effort ? `  ${effort}` : ''}${lockedInfo}${worktreeInfo}`,
             value: { task, worktree },
         };
     });
@@ -49,7 +54,7 @@ export async function releaseCommand() {
     // Confirm
     console.log();
     console.log(pc.yellow(`This will:`));
-    console.log(pc.dim(`  • Release the lock on task #${task.id}`));
+    console.log(pc.dim(`  • Release the lock on task #${shortIdRaw(task.id)}`));
     console.log(pc.dim(`  • Set task status back to "planned"`));
     if (worktree) {
         console.log(pc.dim(`  • Optionally remove the worktree`));
@@ -66,7 +71,7 @@ export async function releaseCommand() {
     // Abandon the task in Damper
     try {
         await api.abandonTask(task.id, 'Released via CLI');
-        console.log(pc.green(`\n✓ Task #${task.id} released to planned status`));
+        console.log(pc.green(`\n✓ Task #${shortIdRaw(task.id)} released to planned status`));
     }
     catch (err) {
         const error = err;

package/dist/commands/start.js

@@ -7,6 +7,7 @@ import { pickTask } from '../ui/task-picker.js';
 import { launchClaude, postTaskFlow, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.js';
 import { getWorktreesForProject, cleanupStaleWorktrees } from '../services/state.js';
 import { getApiKey, isProjectConfigured, getProjectConfigPath } from '../services/config.js';
+import { shortIdRaw } from '../ui/format.js';
 export async function startCommand(options) {
     // Check Claude CLI first
     const claudeInstalled = await isClaudeInstalled();
@@ -56,6 +57,7 @@ export async function startCommand(options) {
     let taskId;
     let taskTitle;
     let isResume = false;
+    let isNewTask = false;
     let worktreePath;
     let forceTakeover = options.force || false;
     if (options.taskId) {
@@ -68,10 +70,10 @@ export async function startCommand(options) {
         if (existingWorktree && fs.existsSync(existingWorktree.path)) {
             isResume = true;
             worktreePath = existingWorktree.path;
-            console.log(pc.cyan(`\nResuming task #${taskId}: ${taskTitle}`));
+            console.log(pc.cyan(`\nResuming task #${shortIdRaw(taskId)}: ${taskTitle}`));
         }
         else {
-            console.log(pc.cyan(`\nStarting task #${taskId}: ${taskTitle}`));
+            console.log(pc.cyan(`\nStarting task #${shortIdRaw(taskId)}: ${taskTitle}`));
         }
     }
     else {
@@ -88,6 +90,7 @@ export async function startCommand(options) {
         taskId = result.task.id;
         taskTitle = result.task.title;
         isResume = result.isResume;
+        isNewTask = result.isNewTask || false;
         forceTakeover = result.forceTakeover || options.force || false;
         if (result.worktree) {
             worktreePath = result.worktree.path;
@@ -95,7 +98,7 @@ export async function startCommand(options) {
     }
     if (isResume && worktreePath) {
         // Resume existing worktree
-        console.log(pc.green(`\n✓ Resuming: #${taskId} ${taskTitle}`));
+        console.log(pc.green(`\n✓ Resuming: #${shortIdRaw(taskId)} ${taskTitle}`));
         console.log(pc.dim(`  Worktree: ${worktreePath}`));
         // Refresh context with latest from Damper
         console.log(pc.dim('\nRefreshing context from Damper...'));
@@ -166,5 +169,6 @@ export async function startCommand(options) {
         taskId: result.taskId,
         apiKey: result.apiKey,
         projectRoot,
+        isNewTask,
     });
 }

package/dist/commands/status.js

@@ -3,6 +3,7 @@ import pc from 'picocolors';
 import { getWorktrees, cleanupStaleWorktrees } from '../services/state.js';
 import { createDamperApi } from '../services/damper-api.js';
 import { getGitRoot } from '../services/worktree.js';
+import { shortId, getTypeIcon, getPriorityIcon, formatEffort, formatSubtaskProgress, relativeTime, statusColor as getStatusColor, } from '../ui/format.js';
 export async function statusCommand() {
     // Clean up stale entries first
     const stale = cleanupStaleWorktrees();
@@ -49,25 +50,43 @@ export async function statusCommand() {
         console.log();
         for (const wt of projectWorktrees) {
             const exists = fs.existsSync(wt.path);
-            const shortTaskId = wt.taskId.slice(0, 8);
-            // Try to get task status and title
-            let taskStatus = '';
-            let taskTitle = '';
+            const statusIcon = exists ? pc.green('●') : pc.red('○');
+            // Try to get task details from Damper
             if (api) {
                 try {
                     const task = await api.getTask(wt.taskId);
-                    const statusColor = task.status === 'done' ? pc.green : task.status === 'in_progress' ? pc.yellow : pc.dim;
-                    taskStatus = statusColor(`[${task.status}]`);
-                    taskTitle = task.title;
+                    const priorityIcon = getPriorityIcon(task.priority);
+                    const typeIcon = getTypeIcon(task.type);
+                    const colorFn = getStatusColor(task.status);
+                    const statusBadge = colorFn(`[${task.status}]`);
+                    const effort = formatEffort(task.effort);
+                    const progress = formatSubtaskProgress(task.subtaskProgress);
+                    const time = relativeTime(wt.createdAt);
+                    console.log(`  ${statusIcon} ${priorityIcon}${typeIcon} ${shortId(task.id)}  ${task.title} ${statusBadge}${effort ? `  ${effort}` : ''}`);
+                    const metaParts = [wt.branch];
+                    if (time)
+                        metaParts.push(time);
+                    if (progress)
+                        metaParts.push(progress);
+                    console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
                 }
                 catch {
-                    taskStatus = pc.dim('[unknown]');
+                    console.log(`  ${statusIcon} ${shortId(wt.taskId)} ${pc.dim('[unknown]')}`);
+                    const time = relativeTime(wt.createdAt);
+                    const metaParts = [wt.branch];
+                    if (time)
+                        metaParts.push(time);
+                    console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
                 }
             }
-            const statusIcon = exists ? pc.green('●') : pc.red('○');
-            const titlePart = taskTitle ? `  ${taskTitle}` : '';
-            console.log(`  ${statusIcon} ${pc.cyan(`#${shortTaskId}`)}${titlePart} ${taskStatus}`);
-            console.log(`    ${wt.branch} ${pc.dim('·')} ${pc.dim(`created ${new Date(wt.createdAt).toLocaleDateString()}`)}`);
+            else {
+                console.log(`  ${statusIcon} ${shortId(wt.taskId)}`);
+                const time = relativeTime(wt.createdAt);
+                const metaParts = [wt.branch];
+                if (time)
+                    metaParts.push(time);
+                console.log(`    ${metaParts.join(` ${pc.dim('\u00B7')} `)}`);
+            }
             console.log();
         }
     }

package/dist/services/claude.d.ts

@@ -44,6 +44,7 @@ export declare function postTaskFlow(options: {
     taskId: string;
     apiKey: string;
     projectRoot: string;
+    isNewTask?: boolean;
 }): Promise<void>;
 /**
  * Check if Claude Code CLI is installed

package/dist/services/claude.js

@@ -4,6 +4,7 @@ import * as os from 'node:os';
 import { spawn } from 'node:child_process';
 import { execa } from 'execa';
 import pc from 'picocolors';
+import { shortIdRaw } from '../ui/format.js';
 const CLAUDE_SETTINGS_DIR = path.join(os.homedir(), '.claude');
 const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_SETTINGS_DIR, 'settings.json');
 /**
@@ -85,7 +86,7 @@ export function configureDamperMcp() {
  */
 export async function launchClaude(options) {
     const { cwd, taskId, taskTitle, apiKey, yolo } = options;
-    console.log(pc.green(`\nStarting Claude Code for task #${taskId}: ${taskTitle}`));
+    console.log(pc.green(`\nStarting Claude Code for task #${shortIdRaw(taskId)}: ${taskTitle}`));
     console.log(pc.dim(`Directory: ${cwd}`));
     console.log();
     // Show workflow explanation
@@ -138,16 +139,14 @@ export async function launchClaude(options) {
         });
         child.on('close', () => resolve());
     });
-    // Post-task flow
-    console.log(pc.dim('\n─────────────────────────────────────────'));
-    console.log(pc.bold('\nClaude session ended.\n'));
+    console.log(pc.dim('\n─────────────────────────────────────────\n'));
     return { cwd, taskId, apiKey };
 }
 /**
  * Post-task actions after Claude exits
  */
 export async function postTaskFlow(options) {
-    const { cwd, taskId, apiKey, projectRoot } = options;
+    const { cwd, taskId, apiKey, projectRoot, isNewTask } = options;
     const { confirm, select } = await import('@inquirer/prompts');
     const { createDamperApi } = await import('./damper-api.js');
     const { removeWorktreeDir } = await import('./worktree.js');
@@ -155,15 +154,34 @@ export async function postTaskFlow(options) {
     // Check task status from Damper
     let taskStatus;
     let taskTitle;
+    let hasCommits = false;
     try {
         const api = createDamperApi(apiKey);
         const task = await api.getTask(taskId);
         taskStatus = task.status;
         taskTitle = task.title;
+        hasCommits = (task.commits?.length ?? 0) > 0;
     }
     catch {
         console.log(pc.yellow('Could not fetch task status from Damper.'));
     }
+    // Clean up CLI-generated modifications to tracked files before checking git status
+    // The CLI appends a "## Current Task:" section to CLAUDE.md which is never meant to be committed
+    try {
+        const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+        if (fs.existsSync(claudeMdPath)) {
+            const content = fs.readFileSync(claudeMdPath, 'utf-8');
+            const marker = '## Current Task:';
+            const markerIndex = content.indexOf(marker);
+            if (markerIndex !== -1) {
+                const restored = content.slice(0, markerIndex).trimEnd() + '\n';
+                fs.writeFileSync(claudeMdPath, restored, 'utf-8');
+            }
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
     // Check git status
     let hasUnpushedCommits = false;
     let hasUncommittedChanges = false;
@@ -219,6 +237,7 @@ export async function postTaskFlow(options) {
     console.log();
     // Offer actions based on state
     const hasChanges = hasUnpushedCommits || hasUncommittedChanges;
+    let worktreeRemoved = false;
     if (hasChanges) {
         if (hasUncommittedChanges) {
             console.log(pc.yellow('⚠ There are uncommitted changes. You may want to commit them first.\n'));
@@ -285,6 +304,7 @@ export async function postTaskFlow(options) {
         if (shouldCleanup) {
             try {
                 await removeWorktreeDir(cwd, projectRoot);
+                worktreeRemoved = true;
                 console.log(pc.green('✓ Worktree and branch removed\n'));
             }
             catch (err) {
@@ -313,6 +333,7 @@ export async function postTaskFlow(options) {
         if (shouldRemove) {
             try {
                 await removeWorktreeDir(cwd, projectRoot);
+                worktreeRemoved = true;
                 console.log(pc.green('✓ Worktree and branch removed\n'));
             }
             catch (err) {
@@ -320,10 +341,44 @@ export async function postTaskFlow(options) {
                 console.log(pc.red(`Failed to remove worktree: ${error.message}\n`));
             }
         }
-        else {
-            console.log(pc.dim('\nWorktree kept. Run `npx @damper/cli cleanup` to remove later.\n'));
+    }
+    // Offer to delete CLI-created tasks with no work done
+    let taskDeleted = false;
+    if (isNewTask && !hasCommits && taskStatus !== 'done') {
+        const shouldDelete = await confirm({
+            message: 'No work was committed. Remove task from backlog?',
+            default: true,
+        });
+        if (shouldDelete) {
+            try {
+                const api = createDamperApi(apiKey);
+                await api.deleteTask(taskId);
+                taskDeleted = true;
+                console.log(pc.green('✓ Task removed from backlog\n'));
+            }
+            catch (err) {
+                const error = err;
+                console.log(pc.yellow(`Could not delete task: ${error.message}\n`));
+            }
+        }
+    }
+    // Final summary
+    console.log(pc.dim('─────────────────────────────────────────'));
+    if (taskDeleted) {
+        console.log(pc.dim(`\n  Task removed. No changes saved.\n`));
+    }
+    else {
+        const statusColor = taskStatus === 'done' ? pc.green : taskStatus === 'in_progress' ? pc.yellow : pc.dim;
+        const statusLabel = taskStatus || 'unknown';
+        console.log(pc.bold(`\n  #${shortIdRaw(taskId)} ${taskTitle || 'Unknown task'}`) + `  ${statusColor(statusLabel)}`);
+        if (!worktreeRemoved) {
+            console.log(pc.dim(`  ${cwd}`));
+            console.log(`\n  To continue, run:`);
+            console.log(pc.cyan(`    cd ${cwd} && claude -c`));
+            console.log(pc.dim(`    or: npx @damper/cli --task ${taskId}`));
         }
     }
+    console.log();
 }
 /**
  * Check if Claude Code CLI is installed

package/dist/services/damper-api.d.ts

@@ -170,7 +170,11 @@ export declare class DamperApi {
     }>;
     getModule(name: string): Promise<Module>;
     getAgentInstructions(format?: 'markdown' | 'section'): Promise<AgentInstructions>;
-    createTask(title: string, type?: 'bug' | 'feature' | 'improvement' | 'task'): Promise<Task>;
+    createTask(title: string, type?: 'bug' | 'feature' | 'improvement' | 'task', description?: string): Promise<Task>;
+    deleteTask(taskId: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
     getLinkedFeedback(taskId: string): Promise<Array<{
         id: string;
         title: string;

package/dist/services/damper-api.js

@@ -152,8 +152,12 @@ This project uses Damper MCP for task tracking. **You MUST follow this workflow.
         };
     }
     // Create task
-    async createTask(title, type = 'task') {
-        return this.request('POST', '/api/agent/tasks', { title, type, status: 'planned' });
+    async createTask(title, type = 'task', description) {
+        return this.request('POST', '/api/agent/tasks', { title, type, status: 'planned', description });
+    }
+    // Delete task (only planned, no commits)
+    async deleteTask(taskId) {
+        return this.request('DELETE', `/api/agent/tasks/${taskId}`);
     }
     // Feedback
     async getLinkedFeedback(taskId) {

package/dist/templates/CLAUDE_APPEND.md.js

@@ -24,10 +24,11 @@ ${planSection}
 - \`.claude/settings.local.json\`
 
 **Your responsibilities (via Damper MCP):**
-1. Use \`add_commit\` after each git commit
-2. Use \`add_note\` ONLY for non-obvious approach decisions (e.g. "Decision: chose X because Y")
-3. When done: call \`complete_task\` with a one-line summary
-4. If stopping early: call \`abandon_task\` with what remains and blockers
+1. After planning, use \`update_task\` to set a concise title if the current one looks like instructions/description
+2. Use \`add_commit\` after each git commit
+3. Use \`add_note\` ONLY for non-obvious approach decisions (e.g. "Decision: chose X because Y")
+4. When done: call \`complete_task\` with a one-line summary
+5. If stopping early: call \`abandon_task\` with what remains and blockers
 
 The CLI just bootstrapped this environment - YOU handle the task lifecycle.
 `.trim();

package/dist/ui/format.d.ts

@@ -0,0 +1,32 @@
+import type { Task } from '../services/damper-api.js';
+/** Colored short ID: dim `#` + cyan first 8 chars */
+export declare function shortId(id: string): string;
+/** Plain 8-char slice (for use inside other color wrappers) */
+export declare function shortIdRaw(id: string): string;
+/** Type emoji icon */
+export declare function getTypeIcon(type: string): string;
+/** Priority prefix: red/yellow circle + space, or empty */
+export declare function getPriorityIcon(priority: string): string;
+/** Dim effort badge like `▪ L`, or empty string */
+export declare function formatEffort(effort: string | null | undefined): string;
+/** Dim feedback count like `💬 3`, or empty string */
+export declare function formatFeedback(count: number | null | undefined): string;
+/** Dim labels joined with ` · `, or empty string */
+export declare function formatLabels(labels: string[] | null | undefined): string;
+/** 10-char progress bar: green filled, dim empty, with count */
+export declare function formatSubtaskProgress(progress: {
+    done: number;
+    total: number;
+} | null | undefined): string;
+/** Relative time string from date, no dependencies */
+export declare function relativeTime(date: string | Date | null | undefined): string;
+/** Returns a picocolors function for the given status */
+export declare function statusColor(status: string): (s: string) => string;
+/** Terminal width (min 80) */
+export declare function getTerminalWidth(): number;
+/** Section header spanning terminal width: `── Label ───────────` */
+export declare function sectionHeader(label: string, width?: number): string;
+/** Compact one-liner: `🔴 ✨ #a1b2c3d4  Title  ▪ L` */
+export declare function formatTaskLine(task: Task): string;
+/** Dim metadata second line with segments joined by ` · ` */
+export declare function formatTaskMeta(task: Task): string;

package/dist/ui/format.js

@@ -0,0 +1,144 @@
+import pc from 'picocolors';
+/** Colored short ID: dim `#` + cyan first 8 chars */
+export function shortId(id) {
+    return `${pc.dim('#')}${pc.cyan(id.slice(0, 8))}`;
+}
+/** Plain 8-char slice (for use inside other color wrappers) */
+export function shortIdRaw(id) {
+    return id.slice(0, 8);
+}
+/** Type emoji icon */
+export function getTypeIcon(type) {
+    switch (type) {
+        case 'bug': return '\u{1F41B}';
+        case 'feature': return '\u{2728}';
+        case 'improvement': return '\u{1F4A1}';
+        default: return '\u{1F4CC}';
+    }
+}
+/** Priority prefix: red/yellow circle + space, or empty */
+export function getPriorityIcon(priority) {
+    switch (priority) {
+        case 'high': return '\u{1F534} ';
+        case 'medium': return '\u{1F7E1} ';
+        default: return '';
+    }
+}
+/** Dim effort badge like `▪ L`, or empty string */
+export function formatEffort(effort) {
+    if (!effort)
+        return '';
+    return pc.dim(`\u25AA ${effort.toUpperCase()}`);
+}
+/** Dim feedback count like `💬 3`, or empty string */
+export function formatFeedback(count) {
+    if (!count)
+        return '';
+    return pc.dim(`\u{1F4AC} ${count}`);
+}
+/** Dim labels joined with ` · `, or empty string */
+export function formatLabels(labels) {
+    if (!labels || labels.length === 0)
+        return '';
+    return pc.dim(labels.join(' \u00B7 '));
+}
+/** 10-char progress bar: green filled, dim empty, with count */
+export function formatSubtaskProgress(progress) {
+    if (!progress || progress.total === 0)
+        return '';
+    const { done, total } = progress;
+    const width = 10;
+    const filled = Math.round((done / total) * width);
+    const empty = width - filled;
+    const bar = pc.green('\u2501'.repeat(filled)) + pc.dim('\u2591'.repeat(empty));
+    return `${bar} ${done}/${total}`;
+}
+/** Relative time string from date, no dependencies */
+export function relativeTime(date) {
+    if (!date)
+        return '';
+    const now = Date.now();
+    const then = date instanceof Date ? date.getTime() : new Date(date).getTime();
+    if (isNaN(then))
+        return '';
+    const diffMs = now - then;
+    if (diffMs < 0)
+        return 'just now';
+    const seconds = Math.floor(diffMs / 1000);
+    if (seconds < 60)
+        return 'just now';
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 14)
+        return `${days}d ago`;
+    const weeks = Math.floor(days / 7);
+    if (weeks < 8)
+        return `${weeks}w ago`;
+    const months = Math.floor(days / 30);
+    if (months < 12)
+        return `${months}mo ago`;
+    const years = Math.floor(days / 365);
+    return `${years}y ago`;
+}
+/** Returns a picocolors function for the given status */
+export function statusColor(status) {
+    switch (status) {
+        case 'done': return pc.green;
+        case 'in_progress': return pc.yellow;
+        default: return pc.dim;
+    }
+}
+/** Terminal width (min 80) */
+export function getTerminalWidth() {
+    return Math.max(80, process.stdout.columns || 80);
+}
+/** Section header spanning terminal width: `── Label ───────────` */
+export function sectionHeader(label, width) {
+    const w = width ?? getTerminalWidth();
+    const prefix = `── ${label} `;
+    const remaining = Math.max(0, w - prefix.length);
+    return pc.dim(prefix + '─'.repeat(remaining));
+}
+/** Compact one-liner: `🔴 ✨ #a1b2c3d4  Title  ▪ L` */
+export function formatTaskLine(task) {
+    const priority = getPriorityIcon(task.priority);
+    const icon = getTypeIcon(task.type);
+    const id = shortId(task.id);
+    const effort = formatEffort(task.effort);
+    const parts = [
+        `${priority}${icon} ${id}  ${task.title}`,
+    ];
+    if (effort)
+        parts.push(effort);
+    return parts.join('  ');
+}
+/** Dim metadata second line with segments joined by ` · ` */
+export function formatTaskMeta(task) {
+    const segments = [];
+    if (task.quarter) {
+        segments.push(pc.dim(task.quarter));
+    }
+    if (task.hasImplementationPlan) {
+        segments.push(pc.dim('has plan'));
+    }
+    const progress = formatSubtaskProgress(task.subtaskProgress);
+    if (progress) {
+        segments.push(progress);
+    }
+    const feedback = formatFeedback(task.feedbackCount);
+    if (feedback) {
+        segments.push(feedback);
+    }
+    const labels = formatLabels(task.labels);
+    if (labels) {
+        segments.push(labels);
+    }
+    if (segments.length === 0)
+        return '';
+    return segments.join(` ${pc.dim('\u00B7')} `);
+}

package/dist/ui/task-picker.d.ts

@@ -11,6 +11,7 @@ interface TaskPickerResult {
     worktree?: WorktreeState;
     isResume: boolean;
     forceTakeover?: boolean;
+    isNewTask?: boolean;
 }
 export declare function pickTask(options: TaskPickerOptions): Promise<TaskPickerResult | null>;
 export {};

package/dist/ui/task-picker.js

@@ -1,62 +1,81 @@
 import { select, confirm, input, Separator } from '@inquirer/prompts';
 import pc from 'picocolors';
-function shortId(id) {
-    return id.slice(0, 8);
+import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort, formatSubtaskProgress, sectionHeader, relativeTime, getTerminalWidth, } from './format.js';
+// Layout constants (terminal column widths)
+const CURSOR_WIDTH = 2; // inquirer select prefix (❯ or  )
+const PRIORITY_WIDTH = 3; // emoji(2) + space(1), or 3 spaces
+const TYPE_WIDTH = 2; // emoji(2)
+const GAP1 = 1; // space after type
+const ID_WIDTH = 9; // # + 8 chars
+const GAP2 = 2; // spaces after ID
+const GAP3 = 2; // spaces between title and meta
+const META_RESERVE = 16; // max width for right-side meta
+const MIN_TITLE = 20; // minimum title column width
+const LEFT_FIXED = CURSOR_WIDTH + PRIORITY_WIDTH + TYPE_WIDTH + GAP1 + ID_WIDTH + GAP2; // 19
+const INDENT_WIDTH = PRIORITY_WIDTH + TYPE_WIDTH + GAP1 + ID_WIDTH + GAP2; // 17 (without cursor)
+function getTitleWidth() {
+    const termWidth = getTerminalWidth();
+    return Math.max(MIN_TITLE, termWidth - LEFT_FIXED - GAP3 - META_RESERVE);
 }
-function getTypeIcon(type) {
-    switch (type) {
-        case 'bug': return '🐛';
-        case 'feature': return '✨';
-        case 'improvement': return '💡';
-        default: return '📌';
-    }
-}
-function getPriorityIcon(priority) {
-    switch (priority) {
-        case 'high': return '🔴 ';
-        case 'medium': return '🟡 ';
-        default: return '';
-    }
+function formatTableRow(task, titleWidth) {
+    // Priority: always 3 terminal cols
+    const hasPriority = task.priority === 'high' || task.priority === 'medium';
+    const priorityStr = hasPriority ? getPriorityIcon(task.priority) : '   ';
+    // Type icon: 2 terminal cols
+    const typeStr = getTypeIcon(task.type);
+    // ID: 9 visible chars
+    const idStr = shortId(task.id);
+    // Title: padded or truncated to fixed width
+    const titleStr = task.title.length > titleWidth
+        ? task.title.slice(0, titleWidth - 1) + '\u2026'
+        : task.title + ' '.repeat(titleWidth - task.title.length);
+    // Right-side meta (compact)
+    const metaParts = [];
+    if (task.effort)
+        metaParts.push(formatEffort(task.effort));
+    if (task.feedbackCount)
+        metaParts.push(pc.dim(`\u{1F4AC}${task.feedbackCount}`));
+    if (task.subtaskProgress?.total)
+        metaParts.push(formatSubtaskProgress(task.subtaskProgress));
+    const meta = metaParts.join('  ');
+    return `${priorityStr}${typeStr} ${idStr}  ${titleStr}  ${meta}`;
 }
-function formatTaskChoice(choice) {
-    const { task } = choice;
-    const typeIcon = getTypeIcon(task.type);
-    const priorityIcon = getPriorityIcon(task.priority);
-    const id = `${pc.dim('#')}${pc.cyan(shortId(task.id))}`;
+function formatTaskChoice(choice, titleWidth) {
+    const firstLine = formatTableRow(choice.task, titleWidth);
+    const indent = ' '.repeat(INDENT_WIDTH);
     if (choice.type === 'in_progress') {
         const worktreeName = choice.worktree.path.split('/').pop() || choice.worktree.path;
-        let description = `${priorityIcon}${typeIcon} ${id}  ${task.title}`;
-        description += `\n      ${pc.dim(worktreeName)}`;
+        const time = relativeTime(choice.worktree.createdAt);
+        const metaParts = [worktreeName];
+        if (time)
+            metaParts.push(time);
+        let description = `${firstLine}\n${indent}${pc.dim(metaParts.join(' \u00B7 '))}`;
         if (choice.lastNote) {
-            const note = choice.lastNote.length > 60 ? choice.lastNote.slice(0, 60) + '...' : choice.lastNote;
-            description += `\n      ${pc.dim(`Last: "${note}"`)}`;
+            const maxNoteWidth = titleWidth;
+            const note = choice.lastNote.length > maxNoteWidth ? choice.lastNote.slice(0, maxNoteWidth - 3) + '...' : choice.lastNote;
+            description += `\n${indent}${pc.dim(`Last: "${note}"`)}`;
         }
         return description;
     }
     if (choice.type === 'locked') {
-        let description = `${priorityIcon}${typeIcon} ${id}  ${task.title}`;
-        description += `\n      ${pc.yellow(`locked by ${choice.lockedBy}`)}`;
-        return description;
-    }
-    // Available task
-    let description = `${priorityIcon}${typeIcon} ${id}  ${task.title}`;
-    const meta = [];
-    if (task.quarter) {
-        meta.push(task.quarter);
-    }
-    if (task.hasImplementationPlan) {
-        meta.push('has plan');
-    }
-    if (task.subtaskProgress) {
-        meta.push(`${task.subtaskProgress.done}/${task.subtaskProgress.total} subtasks`);
-    }
-    if (meta.length > 0) {
-        description += `\n      ${pc.dim(meta.join(' · '))}`;
-    }
-    return description;
+        return `${firstLine}\n${indent}${pc.yellow(`locked by ${choice.lockedBy}`)}`;
+    }
+    // Available task - add secondary meta line if there's useful info
+    const secondaryParts = [];
+    if (choice.task.quarter)
+        secondaryParts.push(choice.task.quarter);
+    if (choice.task.hasImplementationPlan)
+        secondaryParts.push('has plan');
+    if (choice.task.labels?.length)
+        secondaryParts.push(choice.task.labels.join(' \u00B7 '));
+    if (secondaryParts.length > 0) {
+        return `${firstLine}\n${indent}${pc.dim(secondaryParts.join(` \u00B7 `))}`;
+    }
+    return firstLine;
 }
 export async function pickTask(options) {
     const { api, worktrees, typeFilter, statusFilter } = options;
+    const titleWidth = getTitleWidth();
     // Fetch tasks from Damper
     const { tasks, project } = await api.listTasks({
         status: statusFilter || 'all',
@@ -74,8 +93,6 @@ export async function pickTask(options) {
         const task = tasks.find(t => t.id === worktree.taskId);
         if (task) {
             worktreeTaskIds.add(task.id);
-            // Get last note for display (we'd need to fetch task detail for this)
-            // For now, we'll leave it undefined - the API doesn't include notes in list
             inProgressChoices.push({
                 type: 'in_progress',
                 task,
@@ -91,7 +108,6 @@ export async function pickTask(options) {
             continue;
         const taskAny = task;
         if (task.status === 'in_progress' && taskAny.lockedBy) {
-            // Task is locked by someone else
             lockedChoices.push({
                 type: 'locked',
                 task,
@@ -104,28 +120,28 @@ export async function pickTask(options) {
     }
     const choices = [];
     if (inProgressChoices.length > 0) {
-        choices.push(new Separator(pc.bold(`\n--- In Progress (${inProgressChoices.length}) ---`)));
+        choices.push(new Separator(`\n${sectionHeader(`In Progress (${inProgressChoices.length})`)}`));
         for (const choice of inProgressChoices) {
             choices.push({
-                name: formatTaskChoice(choice),
+                name: formatTaskChoice(choice, titleWidth),
                 value: choice,
             });
         }
     }
     if (availableChoices.length > 0) {
-        choices.push(new Separator(pc.bold(`\n--- Available (${availableChoices.length}) ---`)));
+        choices.push(new Separator(`\n${sectionHeader(`Available (${availableChoices.length})`)}`));
         for (const choice of availableChoices) {
             choices.push({
-                name: formatTaskChoice(choice),
+                name: formatTaskChoice(choice, titleWidth),
                 value: choice,
             });
         }
     }
     if (lockedChoices.length > 0) {
-        choices.push(new Separator(pc.bold(`\n--- Locked (${lockedChoices.length}) ---`)));
+        choices.push(new Separator(`\n${sectionHeader(`Locked (${lockedChoices.length})`)}`));
         for (const choice of lockedChoices) {
             choices.push({
-                name: formatTaskChoice(choice),
+                name: formatTaskChoice(choice, titleWidth),
                 value: choice,
             });
         }
@@ -182,9 +198,9 @@ export async function pickTask(options) {
     };
 }
 async function handleCreateNewTask(api) {
-    const title = await input({
-        message: 'Task title:',
-        validate: (value) => value.trim().length > 0 || 'Title is required',
+    const instructions = await input({
+        message: 'What needs to be done?',
+        validate: (value) => value.trim().length > 0 || 'Instructions are required',
     });
     const type = await select({
         message: 'Task type:',
@@ -195,11 +211,19 @@ async function handleCreateNewTask(api) {
             { name: 'Task', value: 'task' },
         ],
     });
+    // Use instructions as description; derive a placeholder title
+    const trimmed = instructions.trim();
+    const maxTitleLen = 60;
+    const placeholderTitle = trimmed.length <= maxTitleLen
+        ? trimmed
+        : trimmed.slice(0, trimmed.lastIndexOf(' ', maxTitleLen) || maxTitleLen) + '…';
     console.log(pc.dim('\nCreating task in Damper...'));
-    const task = await api.createTask(title.trim(), type);
-    console.log(pc.green(`✓ Created task #${shortId(task.id)}: ${task.title}`));
+    const task = await api.createTask(placeholderTitle, type, trimmed);
+    console.log(pc.green(`✓ Created task #${shortIdRaw(task.id)}: ${task.title}`));
+    console.log(pc.dim('  The agent will refine the title after planning.'));
     return {
         task,
         isResume: false,
+        isNewTask: true,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/cli",
-  "version": "0.6.11",
+  "version": "0.6.13",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {