@damper/cli 0.4.1 → 0.5.0

package/dist/commands/cleanup.js

@@ -72,6 +72,15 @@ export async function cleanupCommand() {
                         hasUncommittedChanges: uncommitted,
                     });
                 }
+                else if (task.status === 'in_progress') {
+                    // Task is still in progress - can drop it
+                    candidates.push({
+                        worktree: wt,
+                        task,
+                        reason: 'in_progress',
+                        hasUncommittedChanges: uncommitted,
+                    });
+                }
             }
             catch {
                 // Could not fetch task - might be deleted
@@ -92,7 +101,7 @@ export async function cleanupCommand() {
         }
     }
     if (candidates.length === 0) {
-        console.log(pc.green('\n✓ All worktrees are for active tasks. Nothing to clean up.\n'));
+        console.log(pc.green('\n✓ No worktrees to clean up.\n'));
         return;
     }
     // Show candidates and let user select
@@ -111,6 +120,9 @@ export async function cleanupCommand() {
             case 'abandoned':
                 reasonBadge = pc.yellow('[abandoned]');
                 break;
+            case 'in_progress':
+                reasonBadge = pc.cyan('[in progress - will release]');
+                break;
             case 'missing':
                 reasonBadge = pc.red('[missing]');
                 break;
@@ -161,6 +173,18 @@ export async function cleanupCommand() {
         const { worktree } = candidate;
         const worktreeName = worktree.path.split('/').pop() || worktree.path;
         try {
+            // Release the task first if it's in progress
+            if (candidate.reason === 'in_progress' && api) {
+                try {
+                    await api.abandonTask(worktree.taskId, 'Dropped via CLI cleanup');
+                    console.log(pc.green(`✓ Released task #${worktree.taskId}`));
+                }
+                catch (err) {
+                    const error = err;
+                    console.log(pc.yellow(`⚠ Could not release task: ${error.message}`));
+                    // Continue with worktree removal anyway
+                }
+            }
             if (candidate.reason === 'missing') {
                 // Just remove from state
                 removeWorktree(worktree.taskId);

package/dist/commands/release.d.ts

@@ -0,0 +1 @@
+export declare function releaseCommand(): Promise<void>;

package/dist/commands/release.js

@@ -0,0 +1,95 @@
+import { confirm, select } from '@inquirer/prompts';
+import pc from 'picocolors';
+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';
+export async function releaseCommand() {
+    // Get project root
+    let projectRoot;
+    try {
+        projectRoot = await getGitRoot(process.cwd());
+    }
+    catch {
+        console.log(pc.red('\nError: Not in a git repository.\n'));
+        process.exit(1);
+    }
+    // Get API key
+    const apiKey = getApiKey(projectRoot);
+    if (!apiKey) {
+        console.log(pc.yellow('\nProject not configured.'));
+        console.log(pc.dim(`Run ${pc.cyan('npx @damper/cli setup')} first.\n`));
+        process.exit(1);
+    }
+    const api = createDamperApi(apiKey);
+    // Get tasks that are in_progress (locked)
+    const { tasks, project } = await api.listTasks({ status: 'in_progress' });
+    if (tasks.length === 0) {
+        console.log(pc.yellow('\nNo in-progress tasks to release.\n'));
+        return;
+    }
+    console.log(pc.bold(`\nProject: ${project}`));
+    console.log(pc.dim('Select a task to release back to planned status.\n'));
+    // Build choices
+    const worktrees = getWorktrees();
+    const choices = tasks.map(task => {
+        const worktree = worktrees.find(w => w.taskId === task.id);
+        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}`,
+            value: { task, worktree },
+        };
+    });
+    const selected = await select({
+        message: 'Select task to release:',
+        choices,
+    });
+    const { task, worktree } = selected;
+    // Confirm
+    console.log();
+    console.log(pc.yellow(`This will:`));
+    console.log(pc.dim(`  • Release the lock on task #${task.id}`));
+    console.log(pc.dim(`  • Set task status back to "planned"`));
+    if (worktree) {
+        console.log(pc.dim(`  • Optionally remove the worktree`));
+    }
+    console.log();
+    const shouldRelease = await confirm({
+        message: 'Release this task?',
+        default: true,
+    });
+    if (!shouldRelease) {
+        console.log(pc.dim('\nCancelled.\n'));
+        return;
+    }
+    // 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`));
+    }
+    catch (err) {
+        const error = err;
+        console.log(pc.red(`\nFailed to release task: ${error.message}\n`));
+        return;
+    }
+    // Offer to remove worktree if exists
+    if (worktree) {
+        const shouldRemoveWorktree = await confirm({
+            message: 'Remove the worktree and branch?',
+            default: false,
+        });
+        if (shouldRemoveWorktree) {
+            try {
+                await removeWorktreeDir(worktree.path, worktree.projectRoot);
+                console.log(pc.green('✓ Worktree and branch removed'));
+            }
+            catch (err) {
+                const error = err;
+                console.log(pc.yellow(`Could not remove worktree: ${error.message}`));
+                removeWorktree(task.id); // At least clean up state
+            }
+        }
+    }
+    console.log();
+}

package/dist/commands/start.d.ts

@@ -3,5 +3,6 @@ export interface StartOptions {
     type?: 'bug' | 'feature' | 'improvement' | 'task';
     status?: 'planned' | 'in_progress' | 'done' | 'all';
     yolo?: boolean;
+    force?: boolean;
 }
 export declare function startCommand(options: StartOptions): Promise<void>;

package/dist/commands/start.js

@@ -57,6 +57,7 @@ export async function startCommand(options) {
     let taskTitle;
     let isResume = false;
     let worktreePath;
+    let forceTakeover = options.force || false;
     if (options.taskId) {
         // Direct task selection
         taskId = options.taskId;
@@ -87,6 +88,7 @@ export async function startCommand(options) {
         taskId = result.task.id;
         taskTitle = result.task.title;
         isResume = result.isResume;
+        forceTakeover = result.forceTakeover || options.force || false;
         if (result.worktree) {
             worktreePath = result.worktree.path;
         }
@@ -108,14 +110,14 @@ export async function startCommand(options) {
         // New task - lock it first
         console.log(pc.dim('\nLocking task in Damper...'));
         try {
-            await api.startTask(taskId);
-            console.log(pc.green('✓ Task locked'));
+            await api.startTask(taskId, forceTakeover);
+            console.log(pc.green(forceTakeover ? '✓ Task lock taken over' : '✓ Task locked'));
         }
         catch (err) {
             const error = err;
             if (error.lockInfo) {
                 console.log(pc.yellow(`\n⚠️  Task is locked by "${error.lockInfo.lockedBy}" since ${error.lockInfo.lockedAt}`));
-                console.log(pc.dim('Use --force to take over the lock (if the other agent abandoned it).\n'));
+                console.log(pc.dim('Use --force to take over the lock.\n'));
                 process.exit(1);
             }
             throw err;

package/dist/index.js

@@ -4,7 +4,8 @@ import { startCommand } from './commands/start.js';
 import { statusCommand } from './commands/status.js';
 import { cleanupCommand } from './commands/cleanup.js';
 import { setupCommand } from './commands/setup.js';
-const VERSION = '0.4.1';
+import { releaseCommand } from './commands/release.js';
+const VERSION = '0.5.0';
 function showHelp() {
     console.log(`
 ${pc.bold('@damper/cli')} - Agent orchestration for Damper tasks
@@ -13,12 +14,14 @@ ${pc.bold('Usage:')}
   npx @damper/cli                    Start working on a task (interactive picker)
   npx @damper/cli setup              Configure Damper MCP and API key
   npx @damper/cli status             Show all in-progress worktrees
-  npx @damper/cli cleanup            Remove worktrees for completed tasks
+  npx @damper/cli cleanup            Remove worktrees (completed, abandoned, or in-progress)
+  npx @damper/cli release            Release a task back to planned status
 
 ${pc.bold('Options:')}
   --task <id>                        Work on a specific task
   --type <type>                      Filter by type: bug, feature, improvement, task
   --status <status>                  Filter by status: planned, in_progress, done, all
+  --force                            Take over a task locked by another agent
   --yolo                             Skip plan mode, auto-accept edits
   --reconfigure                      Change API key (use with setup command)
   -h, --help                         Show this help message
@@ -84,6 +87,9 @@ function parseArgs(args) {
         else if (arg === '--yolo') {
             result.options.yolo = true;
         }
+        else if (arg === '--force') {
+            result.options.force = true;
+        }
         else if (!arg.startsWith('-') && !result.command) {
             result.command = arg;
         }
@@ -112,6 +118,9 @@ async function main() {
             case 'cleanup':
                 await cleanupCommand();
                 break;
+            case 'release':
+                await releaseCommand();
+                break;
             case undefined:
             case 'start':
                 await startCommand(options);

package/dist/services/claude.js

@@ -130,18 +130,22 @@ Once approved, switch to implementation and start logging your work.
         'Self-improvement: If you encounter friction, bugs, or have ideas to improve the CLI/workflow,',
         'use `report_issue` to log them. Your feedback improves tooling for all future tasks.',
     ].join('\n');
-    // Build MCP config with API key so the Damper MCP server can authenticate
-    const mcpConfig = JSON.stringify({
-        damper: {
-            command: 'npx',
-            args: ['-y', '@damper/mcp'],
-            env: { DAMPER_API_KEY: apiKey },
+    // Write MCP config to a temp file (more reliable than passing JSON on command line)
+    const mcpConfigPath = path.join(os.tmpdir(), `damper-mcp-${taskId}.json`);
+    const mcpConfig = {
+        mcpServers: {
+            damper: {
+                command: 'npx',
+                args: ['-y', '@damper/mcp'],
+                env: { DAMPER_API_KEY: apiKey },
+            },
         },
-    });
+    };
+    fs.writeFileSync(mcpConfigPath, JSON.stringify(mcpConfig, null, 2));
     // Build Claude args
     const claudeArgs = [
         '--permission-mode', yolo ? 'acceptEdits' : 'plan',
-        '--mcp-config', mcpConfig,
+        '--mcp-config', mcpConfigPath,
         initialPrompt,
     ];
     // Launch Claude Code in interactive mode
@@ -164,6 +168,15 @@ Once approved, switch to implementation and start logging your work.
         }
         // Claude exited with error - still continue to post-task flow
     }
+    finally {
+        // Clean up temp MCP config file
+        try {
+            fs.unlinkSync(mcpConfigPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
     // Post-task flow
     console.log(pc.dim('\n─────────────────────────────────────────'));
     console.log(pc.bold('\nClaude session ended.\n'));

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

@@ -110,6 +110,11 @@ export declare class DamperApi {
     }>;
     getTask(taskId: string): Promise<TaskDetail>;
     startTask(taskId: string, force?: boolean): Promise<StartTaskResult>;
+    abandonTask(taskId: string, summary?: string): Promise<{
+        id: string;
+        status: string;
+        message: string;
+    }>;
     getProjectContext(taskId?: string): Promise<ContextIndex>;
     getContextSection(section: string): Promise<ContextSection | {
         pattern: string;

package/dist/services/damper-api.js

@@ -50,6 +50,9 @@ export class DamperApi {
     async startTask(taskId, force) {
         return this.request('POST', `/api/agent/tasks/${taskId}/start`, force ? { force: true } : undefined);
     }
+    async abandonTask(taskId, summary) {
+        return this.request('POST', `/api/agent/tasks/${taskId}/abandon`, summary ? { summary } : undefined);
+    }
     // Project Context
     async getProjectContext(taskId) {
         const params = taskId ? `?task_id=${taskId}` : '';

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

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

package/dist/ui/task-picker.js

@@ -1,4 +1,4 @@
-import { select, Separator } from '@inquirer/prompts';
+import { select, confirm, Separator } from '@inquirer/prompts';
 import pc from 'picocolors';
 function getTypeIcon(type) {
     switch (type) {
@@ -30,6 +30,11 @@ function formatTaskChoice(choice) {
         }
         return description;
     }
+    if (choice.type === 'locked') {
+        let description = `${pc.dim('#')}${pc.cyan(task.id)} ${task.title} ${pc.dim(`[${typeIcon}]`)} ${priorityIcon}`;
+        description += pc.yellow(` [locked by ${choice.lockedBy}]`);
+        return description;
+    }
     // Available task
     let description = `${pc.dim('#')}${pc.cyan(task.id)} ${task.title} ${pc.dim(`[${typeIcon}]`)} ${priorityIcon}`;
     if (task.quarter) {
@@ -70,11 +75,26 @@ export async function pickTask(options) {
             });
         }
     }
-    // Available tasks are those not in our worktrees and either planned or in_progress
-    const availableChoices = availableTasks
-        .filter(t => !worktreeTaskIds.has(t.id) && (t.status === 'planned' || t.status === 'in_progress'))
-        .map(task => ({ type: 'available', task }));
-    if (inProgressChoices.length === 0 && availableChoices.length === 0) {
+    // Separate available tasks from locked tasks
+    const availableChoices = [];
+    const lockedChoices = [];
+    for (const task of availableTasks) {
+        if (worktreeTaskIds.has(task.id))
+            continue;
+        const taskAny = task;
+        if (task.status === 'in_progress' && taskAny.lockedBy) {
+            // Task is locked by someone else
+            lockedChoices.push({
+                type: 'locked',
+                task,
+                lockedBy: taskAny.lockedBy,
+            });
+        }
+        else if (task.status === 'planned') {
+            availableChoices.push({ type: 'available', task });
+        }
+    }
+    if (inProgressChoices.length === 0 && availableChoices.length === 0 && lockedChoices.length === 0) {
         console.log(pc.yellow('\nNo tasks available.'));
         if (typeFilter) {
             console.log(pc.dim(`(filtered by type: ${typeFilter})`));
@@ -101,6 +121,15 @@ export async function pickTask(options) {
             });
         }
     }
+    if (lockedChoices.length > 0) {
+        choices.push(new Separator(pc.bold('\n--- Locked Tasks (can take over) ---')));
+        for (const choice of lockedChoices) {
+            choices.push({
+                name: formatTaskChoice(choice),
+                value: choice,
+            });
+        }
+    }
     console.log(pc.bold(`\nProject: ${project}`));
     const selected = await select({
         message: 'Select a task to work on:',
@@ -114,6 +143,24 @@ export async function pickTask(options) {
             isResume: true,
         };
     }
+    if (selected.type === 'locked') {
+        // Prompt to take over
+        console.log();
+        console.log(pc.yellow(`This task is locked by "${selected.lockedBy}".`));
+        const shouldTakeover = await confirm({
+            message: 'Take over this task?',
+            default: true,
+        });
+        if (!shouldTakeover) {
+            console.log(pc.dim('\nCancelled.\n'));
+            return null;
+        }
+        return {
+            task: selected.task,
+            isResume: false,
+            forceTakeover: true,
+        };
+    }
     return {
         task: selected.task,
         isResume: false,

package/package.json

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