@damper/cli 0.9.19 → 0.10.0

package/dist/services/claude.js

@@ -31,33 +31,52 @@ export function getConfiguredApiKey() {
     if (process.env.DAMPER_API_KEY) {
         return process.env.DAMPER_API_KEY;
     }
-    // Then check Claude settings (legacy global key)
+    // Then check Claude settings (global MCP config)
     if (!fs.existsSync(CLAUDE_SETTINGS_FILE)) {
         return undefined;
     }
     try {
         const settings = JSON.parse(fs.readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8'));
-        return settings.mcpServers?.damper?.env?.DAMPER_API_KEY;
+        const config = settings.mcpServers?.damper;
+        if (!config)
+            return undefined;
+        // HTTP config: extract from Authorization header
+        if ('type' in config && config.type === 'http') {
+            const auth = config.headers?.Authorization;
+            return auth?.startsWith('Bearer ') ? auth.slice(7) : undefined;
+        }
+        // Legacy stdio config: extract from env
+        if ('env' in config) {
+            return config.env?.DAMPER_API_KEY;
+        }
+        return undefined;
     }
     catch {
         return undefined;
     }
 }
+/** MCP endpoint URL (matches server /mcp route) */
+const MCP_URL = process.env.DAMPER_API_URL
+    ? `${process.env.DAMPER_API_URL}/mcp`
+    : 'https://api.usedamper.com/mcp';
 /**
- * Get the recommended MCP configuration
- * Note: API key is passed via environment when launching Claude, not stored in config
+ * Get the recommended MCP configuration (hosted Streamable HTTP)
  */
-export function getDamperMcpConfig() {
-    return {
-        command: 'npx',
-        args: ['-y', '@damper/mcp'],
+export function getDamperMcpConfig(apiKey) {
+    const config = {
+        type: 'http',
+        url: MCP_URL,
     };
+    if (apiKey) {
+        config.headers = { Authorization: `Bearer ${apiKey}` };
+    }
+    return config;
 }
 /**
  * Configure Damper MCP in Claude settings (global)
- * Note: API key is NOT stored here - it's passed via environment when launching Claude
+ * With HTTP transport, the API key is stored in the config headers.
  */
-export function configureDamperMcp() {
+export function configureDamperMcp(apiKey) {
     // Ensure directory exists
     if (!fs.existsSync(CLAUDE_SETTINGS_DIR)) {
         fs.mkdirSync(CLAUDE_SETTINGS_DIR, { recursive: true });
@@ -73,11 +92,11 @@ export function configureDamperMcp() {
             settings = {};
         }
     }
-    // Add/update MCP config (without API key - it comes from env)
+    // Add/update MCP config
     if (!settings.mcpServers) {
         settings.mcpServers = {};
     }
-    settings.mcpServers.damper = getDamperMcpConfig();
+    settings.mcpServers.damper = getDamperMcpConfig(apiKey);
     // Write back
     fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
 }
@@ -120,7 +139,7 @@ export async function launchClaude(options) {
     if (!isResume) {
         // Show workflow explanation only for new tasks
         console.log(pc.bold('Workflow:'));
-        console.log(pc.dim('  1. Claude reads TASK_CONTEXT.md and creates a plan'));
+        console.log(pc.dim('  1. Claude fetches task details from Damper MCP and creates a plan'));
         if (!yolo) {
             console.log(pc.dim('  2. You approve the plan before Claude makes changes'));
         }
@@ -130,8 +149,6 @@ export async function launchClaude(options) {
     }
     console.log(pc.bold('When finished:'));
     console.log(pc.dim('  • Push your branch and create a PR if needed'));
-    console.log(pc.dim('  • Run: npx @damper/cli cleanup'));
-    console.log(pc.dim('    (removes worktree and branch)'));
     console.log();
     if (yolo) {
         console.log(pc.yellow('Mode: YOLO (plan then auto-execute)'));
@@ -144,7 +161,7 @@ export async function launchClaude(options) {
     let args;
     if (isResume) {
         // Resume previous conversation so Claude continues where it left off
-        const resumePrompt = `TASK_CONTEXT.md has been refreshed with the latest notes from Damper. Continue working on task #${taskId}: ${taskTitle}`;
+        const resumePrompt = `Continue working on task #${taskId}: ${taskTitle}. Call get_project_context via Damper MCP to refresh context if needed.`;
         args = yolo
             ? ['--continue', '--dangerously-skip-permissions', resumePrompt]
             : ['--continue', resumePrompt];
@@ -153,9 +170,9 @@ export async function launchClaude(options) {
     else {
         // New task - enter plan mode first
         const planInstruction = yolo
-            ? ' After reading TASK_CONTEXT.md, use the EnterPlanMode tool to create an implementation plan, then execute it without waiting for user approval.'
-            : ' After reading TASK_CONTEXT.md, use the EnterPlanMode tool to create an implementation plan for user approval before making any code changes.';
-        const initialPrompt = `IMPORTANT: Start by reading TASK_CONTEXT.md completely. It contains the task description, implementation plan, critical rules, and architecture context.${planInstruction} Task #${taskId}: ${taskTitle}`;
+            ? ' Then use the EnterPlanMode tool to create an implementation plan, then execute it without waiting for user approval.'
+            : ' Then use the EnterPlanMode tool to create an implementation plan for user approval before making any code changes.';
+        const initialPrompt = `IMPORTANT: Start by calling get_project_context via Damper MCP to fetch architecture and conventions, then call start_task to get task details for task #${taskId}: ${taskTitle}.${planInstruction}`;
         args = yolo ? ['--dangerously-skip-permissions', initialPrompt] : [initialPrompt];
         console.log(pc.dim(`Launching Claude in ${cwd}...`));
     }
@@ -194,8 +211,6 @@ export async function postTaskFlow(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');
-    const { removeWorktree } = await import('./state.js');
     // Check task status from Damper
     let taskStatus;
     let taskTitle;
@@ -212,23 +227,6 @@ export async function postTaskFlow(options) {
     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;
@@ -288,7 +286,6 @@ export async function postTaskFlow(options) {
     }
     // 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'));
@@ -316,7 +313,7 @@ export async function postTaskFlow(options) {
                 console.log(pc.red('Failed to fetch origin/main. Check your network connection.\n'));
                 return;
             }
-            // Step 1: Merge origin/main INTO the feature branch (in worktree)
+            // Step 1: Merge origin/main INTO the feature branch
             console.log(pc.dim('Merging main into feature branch...'));
             let mainMergedIntoFeature = false;
             try {
@@ -335,7 +332,7 @@ export async function postTaskFlow(options) {
                     console.log(pc.dim('Cleaning up merge state...'));
                     await execa('git', ['reset', '--merge'], { cwd, stdio: 'pipe' }).catch(() => { });
                 }
-                await launchClaudeForMerge({ cwd, apiKey });
+                await launchClaudeForMerge({ cwd, apiKey, taskTitle });
                 // Verify merge was completed (origin/main should be ancestor of HEAD)
                 try {
                     await execa('git', ['merge-base', '--is-ancestor', 'origin/main', 'HEAD'], { cwd, stdio: 'pipe' });
@@ -391,36 +388,17 @@ export async function postTaskFlow(options) {
             }
         }
     }
-    // Offer cleanup if task is done, in_review, or abandoned
-    if (taskStatus === 'done' || taskStatus === 'in_review' || taskStatus === 'planned') {
-        const statusText = taskStatus === 'done' ? 'completed' : taskStatus === 'in_review' ? 'in review' : 'not started/abandoned';
-        const shouldCleanup = await confirm({
-            message: `Task is ${statusText}. Remove worktree and branch?`,
-            default: taskStatus === 'done',
-        });
-        if (shouldCleanup) {
-            try {
-                await removeWorktreeDir(cwd, projectRoot);
-                worktreeRemoved = true;
-                console.log(pc.green('✓ Worktree and branch removed\n'));
-            }
-            catch (err) {
-                const error = err;
-                console.log(pc.red(`Failed to remove worktree: ${error.message}\n`));
-            }
-        }
-    }
-    else if (taskStatus === 'in_progress') {
+    // Handle task lock based on status
+    if (taskStatus === 'in_progress') {
         // Task not completed - ask whether to keep lock for later resumption
         const exitAction = await select({
             message: 'Task is still in progress. What would you like to do?',
             choices: [
                 { name: 'Keep lock (resume later)', value: 'keep' },
                 { name: 'Release lock (let others pick it up)', value: 'release' },
-                { name: 'Release lock and remove worktree', value: 'release_cleanup' },
             ],
         });
-        if (exitAction === 'release' || exitAction === 'release_cleanup') {
+        if (exitAction === 'release') {
             console.log(pc.dim('\nReleasing task lock...'));
             try {
                 const api = createDamperApi(apiKey);
@@ -431,17 +409,6 @@ export async function postTaskFlow(options) {
                 const error = err;
                 console.log(pc.yellow(`Could not release task: ${error.message}`));
             }
-            if (exitAction === 'release_cleanup') {
-                try {
-                    await removeWorktreeDir(cwd, projectRoot);
-                    worktreeRemoved = true;
-                    console.log(pc.green('✓ Worktree and branch removed\n'));
-                }
-                catch (err) {
-                    const error = err;
-                    console.log(pc.red(`Failed to remove worktree: ${error.message}\n`));
-                }
-            }
         }
         else {
             console.log(pc.green('✓ Lock kept — resume with:'));
@@ -477,11 +444,9 @@ export async function postTaskFlow(options) {
         const statusColor = taskStatus === 'done' ? pc.green : (taskStatus === 'in_progress' || taskStatus === 'in_review') ? 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}`));
+        if (taskStatus === 'in_progress') {
             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(pc.cyan(`    npx @damper/cli --task ${taskId}`));
         }
     }
     console.log();
@@ -556,12 +521,13 @@ export async function launchClaudeForReview(options) {
         `Review task #${taskId} and determine if it is ready to be marked as complete.`,
         '',
         'Steps:',
-        '1. Read TASK_CONTEXT.md (if it exists) to understand the requirements',
-        '2. Check git log and git diff main...HEAD to review what was done',
-        '3. Run the project tests (use `bun run test` from the monorepo root, NEVER `bun test`)',
-        '4. Check the completion checklist via get_project_settings MCP tool',
-        '5. If everything looks good, call complete_task via MCP with a summary and confirmations',
-        '6. If NOT ready, explain what is missing or broken — do NOT call complete_task',
+        '1. Call get_project_context via Damper MCP to understand the project',
+        '2. Call get_task via Damper MCP to get the task details and requirements',
+        '3. Check git log and git diff main...HEAD to review what was done',
+        '4. Run the project tests (use `bun run test` from the monorepo root, NEVER `bun test`)',
+        '5. Check the completion checklist via get_project_settings MCP tool',
+        '6. If everything looks good, call complete_task via MCP with a summary and confirmations',
+        '7. If NOT ready, explain what is missing or broken — do NOT call complete_task',
         '',
         'IMPORTANT: Do NOT make any code changes. This is a review-only session.',
     ].join('\n');
@@ -582,15 +548,42 @@ export async function launchClaudeForReview(options) {
 /**
  * Launch Claude to resolve merge conflicts
  * Uses --allowedTools to restrict Claude to only git/file operations
- * so it doesn't pick up task context and try to work on the task
+ * so it doesn't pick up task context and try to work on the task.
+ * Runs with --dangerously-skip-permissions for fully autonomous resolution.
  */
 async function launchClaudeForMerge(options) {
-    const { cwd, apiKey } = options;
-    const prompt = 'IMPORTANT: Your ONLY job is to resolve merge conflicts. Do NOT read TASK_CONTEXT.md or work on any task. Run: git merge origin/main --no-edit. If there are conflicts, resolve them, stage, and commit. Do not use any MCP tools.';
+    const { cwd, apiKey, taskTitle } = options;
+    const taskContext = taskTitle
+        ? `You are merging a feature branch for task "${taskTitle}" into main.`
+        : 'You are merging a feature branch into main.';
+    const prompt = [
+        `MERGE CONFLICT RESOLUTION — Your ONLY job is to resolve merge conflicts.`,
+        '',
+        taskContext,
+        '',
+        'Steps:',
+        '1. Run: git merge origin/main --no-edit',
+        '2. If there are conflicts, identify all conflicted files with: git diff --name-only --diff-filter=U',
+        '3. Read each conflicted file and resolve the conflicts:',
+        '   - For code conflicts: combine both sides logically, preserving the intent of both the feature branch changes and main branch updates',
+        '   - For package.json / lock files: accept the version that satisfies both sides, preferring the newer version',
+        '4. Stage all resolved files with: git add <file>',
+        '5. Commit the merge with: git commit --no-edit',
+        '6. Verify no conflicts remain with: git diff --name-only --diff-filter=U',
+        '',
+        'IMPORTANT:',
+        '- Do NOT use any MCP tools — only use Bash, Read, Write, Edit, Glob, Grep',
+        '- Do NOT make any changes beyond resolving the merge conflicts',
+        '- If a conflict is too complex to resolve confidently, leave it and explain what needs manual attention',
+    ].join('\n');
     const mergeLabel = 'Resolving merge conflicts';
     setTerminalTitle(mergeLabel);
     await new Promise((resolve) => {
-        const child = spawn('claude', ['--allowedTools', 'Bash,Read,Write,Edit,Glob,Grep', prompt], {
+        const child = spawn('claude', [
+            '--allowedTools', 'Bash,Read,Write,Edit,Glob,Grep',
+            '--dangerously-skip-permissions',
+            prompt,
+        ], {
             cwd,
             stdio: 'inherit',
             env: { ...process.env, DAMPER_API_KEY: apiKey },

package/dist/services/config.js

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { getGitRoot } from './worktree.js';
+import { getGitRoot } from './git.js';
 const CONFIG_DIR = '.damper';
 const CONFIG_FILE = 'config.json';
 /**
@@ -66,7 +66,8 @@ export function getApiKey(projectRoot) {
     return getGlobalApiKey();
 }
 /**
- * Get API key from global MCP settings (legacy)
+ * Get API key from global MCP settings (fallback)
+ * Supports both HTTP (headers.Authorization) and legacy stdio (env.DAMPER_API_KEY) configs.
  */
 function getGlobalApiKey() {
     const settingsPath = path.join(os.homedir(), '.claude', 'settings.json');
@@ -75,7 +76,16 @@ function getGlobalApiKey() {
     }
     try {
         const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
-        return settings.mcpServers?.damper?.env?.DAMPER_API_KEY;
+        const config = settings.mcpServers?.damper;
+        if (!config)
+            return undefined;
+        // HTTP config: extract from Authorization header
+        if (config.type === 'http') {
+            const auth = config.headers?.Authorization;
+            return auth?.startsWith('Bearer ') ? auth.slice(7) : undefined;
+        }
+        // Legacy stdio config: extract from env
+        return config.env?.DAMPER_API_KEY;
     }
     catch {
         return undefined;

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

@@ -18,6 +18,7 @@ export interface Task {
 export interface TaskDetail extends Task {
     description?: string | null;
     implementationPlan?: string | null;
+    userStories?: string | null;
     voteScore: number;
     subtasks?: Array<{
         id: string;

package/dist/services/git.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Get the git root directory for the given path
+ */
+export declare function getGitRoot(dir: string): Promise<string>;

package/dist/services/git.js

@@ -0,0 +1,11 @@
+import { execa } from 'execa';
+/**
+ * Get the git root directory for the given path
+ */
+export async function getGitRoot(dir) {
+    const { stdout } = await execa('git', ['rev-parse', '--show-toplevel'], {
+        cwd: dir,
+        stdio: 'pipe',
+    });
+    return stdout.trim();
+}

package/dist/ui/format.d.ts

@@ -9,7 +9,7 @@ export declare function padStart(str: string, width: number): string;
 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 */
+/** Type indicator — colored circles */
 export declare function getTypeIcon(type: string): string;
 /** Priority prefix: red/yellow circle + space, or empty */
 export declare function getPriorityIcon(priority: string): string;

package/dist/ui/format.js

@@ -22,13 +22,13 @@ export function shortId(id) {
 export function shortIdRaw(id) {
     return id.slice(0, 8);
 }
-/** Type emoji icon */
+/** Type indicator — colored circles */
 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}';
+        case 'bug': return '\u{1F534}';
+        case 'feature': return '\u{1F535}';
+        case 'improvement': return '\u{1F7E3}';
+        default: return '\u{26AA}';
     }
 }
 /** Priority prefix: red/yellow circle + space, or empty */

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

@@ -1,14 +1,11 @@
 import type { Task, DamperApi } from '../services/damper-api.js';
-import type { WorktreeState } from '../services/state.js';
 interface TaskPickerOptions {
     api: DamperApi;
-    worktrees: WorktreeState[];
     typeFilter?: 'bug' | 'feature' | 'improvement' | 'task';
     statusFilter?: 'planned' | 'in_progress' | 'in_review' | 'done' | 'all';
 }
 interface TaskPickerResult {
     task: Task;
-    worktree?: WorktreeState;
     isResume: boolean;
     forceTakeover?: boolean;
     isNewTask?: boolean;

package/dist/ui/task-picker.js

@@ -1,7 +1,7 @@
 import { search, select, confirm, input, Separator } from '@inquirer/prompts';
 import pc from 'picocolors';
 import * as readline from 'readline';
-import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort, formatProgressCompact, formatDueDate, sectionHeader, relativeTime, getTerminalWidth, padEnd, padStart, } from './format.js';
+import { shortId, shortIdRaw, getTypeIcon, getPriorityIcon, formatEffort, formatProgressCompact, formatDueDate, sectionHeader, getTerminalWidth, padEnd, padStart, } 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
@@ -88,18 +88,7 @@ function formatTaskChoice(choice, titleWidth, layout) {
     const firstLine = formatTableRow(choice.task, titleWidth, layout);
     const indent = ' '.repeat(INDENT_WIDTH);
     if (choice.type === 'in_progress') {
-        const worktreeName = choice.worktree.path.split('/').pop() || choice.worktree.path;
-        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 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;
+        return firstLine;
     }
     if (choice.type === 'locked') {
         return `${firstLine}\n${indent}${pc.yellow(`locked by ${choice.lockedBy}`)}`;
@@ -118,7 +107,7 @@ function formatTaskChoice(choice, titleWidth, layout) {
     return firstLine;
 }
 export async function pickTask(options) {
-    const { api, worktrees, typeFilter, statusFilter } = options;
+    const { api, typeFilter, statusFilter } = options;
     // Fetch all tasks from Damper (paginated)
     const { tasks, project } = await api.listAllTasks({
         status: statusFilter || 'all',
@@ -128,33 +117,15 @@ export async function pickTask(options) {
     // Filter out completed tasks unless specifically requested
     const availableTasks = tasks.filter(t => statusFilter === 'done' || statusFilter === 'all' ||
         (t.status === 'planned' || t.status === 'in_progress' || t.status === 'in_review'));
-    // Match worktrees with tasks
+    // Categorize tasks
     const inProgressChoices = [];
-    const worktreeTaskIds = new Set();
-    for (const worktree of worktrees) {
-        const task = tasks.find(t => t.id === worktree.taskId);
-        if (task) {
-            worktreeTaskIds.add(task.id);
-            inProgressChoices.push({
-                type: 'in_progress',
-                task,
-                worktree,
-            });
-        }
-    }
-    // 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) {
-            lockedChoices.push({
-                type: 'locked',
-                task,
-                lockedBy: taskAny.lockedBy,
-            });
+            // Show as "in progress" (resumable) or "locked" depending on who locked it
+            inProgressChoices.push({ type: 'in_progress', task });
         }
         else if (task.status === 'planned' || task.status === 'in_progress' || task.status === 'in_review') {
             availableChoices.push({ type: 'available', task });
@@ -229,7 +200,6 @@ export async function pickTask(options) {
         });
         return {
             task: selected.task,
-            worktree: selected.worktree,
             isResume: true,
             action,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/cli",
-  "version": "0.9.19",
+  "version": "0.10.0",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {
@@ -44,8 +44,7 @@
     "cli",
     "claude",
     "ai",
-    "task-management",
-    "worktree"
+    "task-management"
   ],
   "license": "MIT"
 }

package/dist/commands/cleanup.d.ts

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