@damper/cli 0.9.20 → 0.10.0

package/dist/services/worktree.js

@@ -1,469 +0,0 @@
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { execa } from 'execa';
-import pc from 'picocolors';
-import { addWorktree, removeWorktree, getWorktreeByTaskId } from './state.js';
-/**
- * Convert a task title to a safe slug for branch/directory names
- */
-function slugify(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 50);
-}
-/**
- * Get the project name from package.json or directory name
- */
-function getProjectName(projectRoot) {
-    const packageJsonPath = path.join(projectRoot, 'package.json');
-    if (fs.existsSync(packageJsonPath)) {
-        try {
-            const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-            if (pkg.name) {
-                // Strip scope if present
-                return pkg.name.replace(/^@[^/]+\//, '');
-            }
-        }
-        catch {
-            // Fall through to directory name
-        }
-    }
-    return path.basename(projectRoot);
-}
-/**
- * Detect monorepo structure by looking for workspaces in package.json
- */
-function detectMonorepoPackages(projectRoot) {
-    const packageJsonPath = path.join(projectRoot, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) {
-        return [];
-    }
-    try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        const workspaces = pkg.workspaces || [];
-        const packages = [];
-        for (const pattern of workspaces) {
-            // Simple glob expansion for common patterns
-            if (pattern.includes('*')) {
-                const base = pattern.replace(/\/\*$/, '').replace(/\*$/, '');
-                const basePath = path.join(projectRoot, base);
-                if (fs.existsSync(basePath) && fs.statSync(basePath).isDirectory()) {
-                    const dirs = fs.readdirSync(basePath).filter(d => {
-                        const fullPath = path.join(basePath, d);
-                        return fs.statSync(fullPath).isDirectory() &&
-                            fs.existsSync(path.join(fullPath, 'package.json'));
-                    });
-                    packages.push(...dirs.map(d => path.join(base, d)));
-                }
-            }
-            else {
-                // Direct path
-                const pkgPath = path.join(projectRoot, pattern);
-                if (fs.existsSync(path.join(pkgPath, 'package.json'))) {
-                    packages.push(pattern);
-                }
-            }
-        }
-        return packages;
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Find all node_modules directories to symlink
- */
-function findNodeModulesDirs(projectRoot) {
-    const dirs = [];
-    // Root node_modules
-    const rootModules = path.join(projectRoot, 'node_modules');
-    if (fs.existsSync(rootModules)) {
-        dirs.push('node_modules');
-    }
-    // Monorepo package node_modules
-    const packages = detectMonorepoPackages(projectRoot);
-    for (const pkg of packages) {
-        const pkgModules = path.join(projectRoot, pkg, 'node_modules');
-        if (fs.existsSync(pkgModules)) {
-            dirs.push(path.join(pkg, 'node_modules'));
-        }
-    }
-    return dirs;
-}
-/**
- * Find all .env files to copy
- */
-function findEnvFiles(projectRoot) {
-    const envFiles = [];
-    // Root .env files
-    const rootEnvFiles = ['.env', '.env.local', '.env.development'];
-    for (const envFile of rootEnvFiles) {
-        if (fs.existsSync(path.join(projectRoot, envFile))) {
-            envFiles.push(envFile);
-        }
-    }
-    // Monorepo package .env files
-    const packages = detectMonorepoPackages(projectRoot);
-    for (const pkg of packages) {
-        for (const envFile of rootEnvFiles) {
-            const envPath = path.join(pkg, envFile);
-            if (fs.existsSync(path.join(projectRoot, envPath))) {
-                envFiles.push(envPath);
-            }
-        }
-    }
-    // Common server locations
-    const serverDirs = ['server', 'api', 'backend', 'packages/server'];
-    for (const serverDir of serverDirs) {
-        for (const envFile of rootEnvFiles) {
-            const envPath = path.join(serverDir, envFile);
-            if (fs.existsSync(path.join(projectRoot, envPath)) && !envFiles.includes(envPath)) {
-                envFiles.push(envPath);
-            }
-        }
-    }
-    return envFiles;
-}
-/**
- * Check if a git branch exists
- */
-async function branchExists(branchName, projectRoot) {
-    try {
-        await execa('git', ['rev-parse', '--verify', branchName], {
-            cwd: projectRoot,
-            stdio: 'pipe',
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Create a new git worktree for a task
- */
-export async function createWorktree(options) {
-    const { taskId, taskTitle, projectRoot } = options;
-    // Check if worktree already exists for this task
-    const existing = getWorktreeByTaskId(taskId);
-    if (existing && fs.existsSync(existing.path)) {
-        return {
-            path: existing.path,
-            branch: existing.branch,
-            isNew: false,
-        };
-    }
-    const shortTaskId = taskId.slice(0, 8);
-    const slug = slugify(taskTitle);
-    // Put worktrees in .worktrees folder inside the project
-    const worktreesDir = path.join(projectRoot, '.worktrees');
-    const worktreePath = path.join(worktreesDir, `${shortTaskId}-${slug}`);
-    const branchName = `feature/${slug}`;
-    // Ensure .worktrees is gitignored
-    const gitignorePath = path.join(projectRoot, '.gitignore');
-    if (fs.existsSync(gitignorePath)) {
-        const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
-        if (!gitignore.includes('.worktrees')) {
-            fs.appendFileSync(gitignorePath, '\n# Damper CLI worktrees\n.worktrees/\n');
-            console.log(pc.dim('Added .worktrees/ to .gitignore'));
-        }
-    }
-    else {
-        fs.writeFileSync(gitignorePath, '# Damper CLI worktrees\n.worktrees/\n');
-        console.log(pc.dim('Created .gitignore with .worktrees/'));
-    }
-    // Check if worktree directory already exists
-    if (fs.existsSync(worktreePath)) {
-        console.log(pc.dim(`Worktree directory already exists at ${worktreePath}`));
-        // Check if it's a valid worktree and has the expected branch
-        try {
-            const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-                cwd: worktreePath,
-                stdio: 'pipe',
-            });
-            const currentBranch = stdout.trim();
-            console.log(pc.dim(`Using existing worktree on branch ${currentBranch}`));
-            // Save to state if not tracked
-            const worktreeState = {
-                taskId,
-                path: worktreePath,
-                branch: currentBranch,
-                projectRoot,
-                createdAt: new Date().toISOString(),
-            };
-            addWorktree(worktreeState);
-            return {
-                path: worktreePath,
-                branch: currentBranch,
-                isNew: false,
-            };
-        }
-        catch {
-            // Not a valid git worktree, remove it
-            console.log(pc.dim(`Removing invalid directory at ${worktreePath}...`));
-            fs.rmSync(worktreePath, { recursive: true });
-        }
-    }
-    // Check if branch already exists
-    const branchAlreadyExists = await branchExists(branchName, projectRoot);
-    // Create worktree
-    console.log(pc.dim(`Creating worktree at ${worktreePath}...`));
-    if (branchAlreadyExists) {
-        // Use existing branch
-        console.log(pc.dim(`Using existing branch ${branchName}`));
-        await execa('git', ['worktree', 'add', worktreePath, branchName], {
-            cwd: projectRoot,
-            stdio: 'pipe',
-        });
-    }
-    else {
-        // Create new branch
-        await execa('git', ['worktree', 'add', worktreePath, '-b', branchName], {
-            cwd: projectRoot,
-            stdio: 'pipe',
-        });
-    }
-    // Symlink node_modules
-    const nodeModulesDirs = findNodeModulesDirs(projectRoot);
-    for (const dir of nodeModulesDirs) {
-        const source = path.join(projectRoot, dir);
-        const target = path.join(worktreePath, dir);
-        // Ensure parent directory exists
-        const targetDir = path.dirname(target);
-        if (!fs.existsSync(targetDir)) {
-            fs.mkdirSync(targetDir, { recursive: true });
-        }
-        console.log(pc.dim(`Linking ${dir}...`));
-        await fs.promises.symlink(source, target, 'junction');
-    }
-    // Copy .env files
-    const envFiles = findEnvFiles(projectRoot);
-    if (envFiles.length > 0) {
-        console.log(pc.dim(`Copying ${envFiles.length} .env file(s) to worktree...`));
-        for (const envFile of envFiles) {
-            const source = path.join(projectRoot, envFile);
-            const target = path.join(worktreePath, envFile);
-            // Ensure parent directory exists
-            const targetDir = path.dirname(target);
-            if (!fs.existsSync(targetDir)) {
-                fs.mkdirSync(targetDir, { recursive: true });
-            }
-            console.log(pc.dim(`  ${envFile}`));
-            await fs.promises.copyFile(source, target);
-        }
-    }
-    // Create .mcp.json with Damper MCP configured (project-level MCP config)
-    const mcpConfig = {
-        mcpServers: {
-            damper: {
-                command: 'npx',
-                args: ['-y', '@damper/mcp'],
-                env: {
-                    DAMPER_API_KEY: options.apiKey,
-                },
-            },
-        },
-    };
-    fs.writeFileSync(path.join(worktreePath, '.mcp.json'), JSON.stringify(mcpConfig, null, 2));
-    console.log(pc.dim('Created .mcp.json with Damper MCP'));
-    // Create .claude/settings.local.json - copy root permissions and ensure Damper MCP is allowed
-    const claudeDir = path.join(worktreePath, '.claude');
-    if (!fs.existsSync(claudeDir)) {
-        fs.mkdirSync(claudeDir, { recursive: true });
-    }
-    // Read existing settings from root project
-    const rootSettingsPath = path.join(projectRoot, '.claude', 'settings.local.json');
-    let claudeSettings = {};
-    if (fs.existsSync(rootSettingsPath)) {
-        try {
-            claudeSettings = JSON.parse(fs.readFileSync(rootSettingsPath, 'utf-8'));
-        }
-        catch { }
-    }
-    // Ensure permissions.allow includes damper MCP
-    const permissions = (claudeSettings.permissions ?? {});
-    const allow = Array.isArray(permissions.allow) ? [...permissions.allow] : [];
-    if (!allow.includes('mcp__damper__*')) {
-        allow.unshift('mcp__damper__*');
-    }
-    claudeSettings.permissions = { ...permissions, allow };
-    fs.writeFileSync(path.join(claudeDir, 'settings.local.json'), JSON.stringify(claudeSettings, null, 2));
-    console.log(pc.dim('Created .claude/settings.local.json with root permissions + MCP'));
-    // Save to state
-    const worktreeState = {
-        taskId,
-        path: worktreePath,
-        branch: branchName,
-        projectRoot,
-        createdAt: new Date().toISOString(),
-    };
-    addWorktree(worktreeState);
-    return {
-        path: worktreePath,
-        branch: branchName,
-        isNew: true,
-    };
-}
-/**
- * Remove a git worktree and its branch
- */
-export async function removeWorktreeDir(worktreePath, projectRoot) {
-    console.log(pc.dim(`Removing worktree at ${worktreePath}...`));
-    // Get branch name before removing worktree
-    let branchName;
-    try {
-        const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd: worktreePath,
-            stdio: 'pipe',
-        });
-        branchName = stdout.trim();
-    }
-    catch {
-        // Ignore - might not be able to get branch
-    }
-    // Remove symlinks first to avoid issues
-    const nodeModulesDirs = findNodeModulesDirs(projectRoot);
-    for (const dir of nodeModulesDirs) {
-        const target = path.join(worktreePath, dir);
-        if (fs.existsSync(target)) {
-            try {
-                await fs.promises.unlink(target);
-            }
-            catch {
-                // Ignore errors
-            }
-        }
-    }
-    // Remove worktree
-    await execa('git', ['worktree', 'remove', worktreePath, '--force'], {
-        cwd: projectRoot,
-        stdio: 'pipe',
-    });
-    // Delete the branch if it's a feature branch
-    if (branchName && branchName.startsWith('feature/')) {
-        try {
-            await execa('git', ['branch', '-d', branchName], {
-                cwd: projectRoot,
-                stdio: 'pipe',
-            });
-            console.log(pc.dim(`Deleted branch: ${branchName}`));
-        }
-        catch {
-            // Branch might not be fully merged - try force delete
-            try {
-                await execa('git', ['branch', '-D', branchName], {
-                    cwd: projectRoot,
-                    stdio: 'pipe',
-                });
-                console.log(pc.dim(`Force deleted branch: ${branchName}`));
-            }
-            catch {
-                console.log(pc.yellow(`Could not delete branch: ${branchName}`));
-            }
-        }
-    }
-    // Get the worktree state to find the task ID
-    const state = await import('./state.js');
-    const worktree = state.getWorktreeByPath(worktreePath);
-    if (worktree) {
-        removeWorktree(worktree.taskId);
-    }
-}
-/**
- * List all git worktrees for a project
- */
-export async function listWorktrees(projectRoot) {
-    const { stdout } = await execa('git', ['worktree', 'list', '--porcelain'], {
-        cwd: projectRoot,
-        stdio: 'pipe',
-    });
-    const worktrees = [];
-    let current = {};
-    for (const line of stdout.split('\n')) {
-        if (line.startsWith('worktree ')) {
-            current.path = line.slice(9);
-        }
-        else if (line.startsWith('HEAD ')) {
-            current.head = line.slice(5);
-        }
-        else if (line.startsWith('branch ')) {
-            current.branch = line.slice(7);
-        }
-        else if (line === '' && current.path) {
-            if (current.path && current.branch && current.head) {
-                worktrees.push({
-                    path: current.path,
-                    branch: current.branch,
-                    head: current.head,
-                });
-            }
-            current = {};
-        }
-    }
-    // Handle last entry
-    if (current.path && current.branch && current.head) {
-        worktrees.push({
-            path: current.path,
-            branch: current.branch,
-            head: current.head,
-        });
-    }
-    return worktrees;
-}
-/**
- * Check if a path is inside a git worktree
- */
-export async function isInWorktree(dir) {
-    try {
-        const { stdout } = await execa('git', ['rev-parse', '--is-inside-work-tree'], {
-            cwd: dir,
-            stdio: 'pipe',
-        });
-        return stdout.trim() === 'true';
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Get the git root directory
- */
-export async function getGitRoot(dir) {
-    const { stdout } = await execa('git', ['rev-parse', '--show-toplevel'], {
-        cwd: dir,
-        stdio: 'pipe',
-    });
-    return stdout.trim();
-}
-/**
- * Get the main project root (not a worktree).
- * If we're in a worktree, this returns the main repo's path.
- */
-export async function getMainProjectRoot(dir) {
-    // Get the common git directory (shared by all worktrees)
-    const { stdout: gitCommonDir } = await execa('git', ['rev-parse', '--git-common-dir'], {
-        cwd: dir,
-        stdio: 'pipe',
-    });
-    const commonDir = gitCommonDir.trim();
-    // If it's just '.git', we're in the main repo
-    if (commonDir === '.git') {
-        return getGitRoot(dir);
-    }
-    // Otherwise, the common dir is something like '/path/to/main-repo/.git'
-    // Strip the '/.git' to get the main repo path
-    if (commonDir.endsWith('/.git')) {
-        return commonDir.slice(0, -5);
-    }
-    // Fallback: resolve relative path
-    const gitRoot = await getGitRoot(dir);
-    const resolvedCommon = path.resolve(gitRoot, commonDir);
-    // Strip .git suffix
-    if (resolvedCommon.endsWith('.git')) {
-        return resolvedCommon.slice(0, -4);
-    }
-    // Last resort: just return git root
-    return gitRoot;
-}

package/dist/templates/CLAUDE_APPEND.md.d.ts

@@ -1,7 +0,0 @@
-interface ClaudeAppendOptions {
-    taskId: string;
-    taskTitle: string;
-    yolo?: boolean;
-}
-export declare function generateClaudeAppend(options: ClaudeAppendOptions): string;
-export {};

package/dist/templates/CLAUDE_APPEND.md.js

@@ -1,35 +0,0 @@
-export function generateClaudeAppend(options) {
-    const { taskId, taskTitle, yolo } = options;
-    const planSection = yolo
-        ? `
-**MANDATORY: Plan First, Then Execute**
-Before making ANY code changes, you MUST enter plan mode using the EnterPlanMode tool.
-Read TASK_CONTEXT.md first, then create a plan. Once the plan is ready, execute it without waiting for user approval.
-`
-        : `
-**MANDATORY: Plan Mode**
-Before making ANY code changes, you MUST enter plan mode using the EnterPlanMode tool.
-Read TASK_CONTEXT.md first, then create a plan for user approval. Do NOT write code until the plan is approved.
-`;
-    return `
-## Current Task: #${taskId} ${taskTitle}
-
-**IMPORTANT**: Read TASK_CONTEXT.md for full task details and architecture context.
-If you feel you've lost context, re-read that file.
-${planSection}
-**NEVER commit these files** (they are generated by the CLI and gitignored):
-- \`CLAUDE.md\` changes (this task section is temporary)
-- \`TASK_CONTEXT.md\`
-- \`.mcp.json\`
-- \`.claude/settings.local.json\`
-
-**Your responsibilities (via Damper MCP):**
-1. **Do NOT commit or complete tasks without explicit user confirmation** - Always ask the user before running \`git commit\` or calling \`complete_task\`
-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 user confirms: call \`complete_task\` with summary and \`reviewInstructions\` (what to test/verify)
-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/templates/TASK_CONTEXT.md.d.ts

@@ -1,17 +0,0 @@
-import type { TaskDetail, Module } from '../services/damper-api.js';
-import type { SectionBlockIndex } from '../services/context-bootstrap.js';
-interface TaskContextOptions {
-    task: TaskDetail;
-    criticalRules: string[];
-    completionChecklist?: string[];
-    blockIndices: SectionBlockIndex[];
-    templates: Array<{
-        name: string;
-        description?: string | null;
-        filePattern?: string | null;
-    }>;
-    modules: Module[];
-    damperInstructions: string;
-}
-export declare function generateTaskContext(options: TaskContextOptions): string;
-export {};

package/dist/templates/TASK_CONTEXT.md.js

@@ -1,149 +0,0 @@
-export function generateTaskContext(options) {
-    const { task, criticalRules, completionChecklist, blockIndices, templates, modules, damperInstructions } = options;
-    const typeIcon = task.type === 'bug' ? 'Bug' : task.type === 'feature' ? 'Feature' : task.type === 'improvement' ? 'Improvement' : 'Task';
-    const lines = [];
-    // Header
-    lines.push(`# Task: ${task.title} (#${task.id})`);
-    lines.push('');
-    lines.push(`**Type:** ${typeIcon} | **Status:** ${task.status} | **Priority:** ${task.priority || 'none'}`);
-    if (task.effort)
-        lines.push(`**Effort:** ${task.effort}`);
-    if (task.quarter)
-        lines.push(`**Quarter:** ${task.quarter}`);
-    lines.push('');
-    // Critical Rules
-    if (criticalRules.length > 0) {
-        lines.push('## Critical Rules (DO NOT SKIP)');
-        lines.push('');
-        for (const rule of criticalRules) {
-            lines.push(`- ${rule}`);
-        }
-        lines.push('');
-    }
-    // Completion Checklist
-    if (completionChecklist && completionChecklist.length > 0) {
-        lines.push('## Completion Checklist (required for complete_task)');
-        lines.push('');
-        lines.push('You MUST verify each item and pass them as `confirmations` when calling `complete_task`:');
-        lines.push('');
-        for (const item of completionChecklist) {
-            lines.push(`- [ ] ${item}`);
-        }
-        lines.push('');
-    }
-    // Damper Workflow
-    lines.push('## Damper Workflow');
-    lines.push('');
-    lines.push(damperInstructions);
-    lines.push('');
-    // CLI & Tooling Info
-    lines.push('## About This Session');
-    lines.push('');
-    lines.push('You were launched by `@damper/cli` (npm package). The CLI:');
-    lines.push('- Created this git worktree for isolated work');
-    lines.push('- Generated this TASK_CONTEXT.md from Damper API');
-    lines.push('- Configured Damper MCP tools for task lifecycle');
-    lines.push('');
-    lines.push('**Cleanup:** Ask the user for confirmation before committing or completing the task.');
-    lines.push('Once confirmed, call `complete_task` or `abandon_task`. The user will run');
-    lines.push('`npx @damper/cli cleanup` to remove the worktree and branch - you don\'t need to');
-    lines.push('provide manual cleanup instructions.');
-    lines.push('');
-    lines.push('**Help improve the tooling:** If you encounter friction, bugs, or have ideas,');
-    lines.push('use `report_issue` to log them. Your feedback improves tooling for all future tasks.');
-    lines.push('');
-    // Task Description
-    if (task.description) {
-        lines.push('## Task Description');
-        lines.push('');
-        lines.push(task.description);
-        lines.push('');
-    }
-    // Implementation Plan
-    if (task.implementationPlan) {
-        lines.push('## Implementation Plan');
-        lines.push('');
-        lines.push(task.implementationPlan);
-        lines.push('');
-    }
-    // Subtasks
-    if (task.subtasks && task.subtasks.length > 0) {
-        const done = task.subtasks.filter(s => s.done).length;
-        lines.push(`## Subtasks (${done}/${task.subtasks.length})`);
-        lines.push('');
-        for (const subtask of task.subtasks) {
-            lines.push(`- [${subtask.done ? 'x' : ' '}] ${subtask.title} (id: ${subtask.id})`);
-        }
-        lines.push('');
-    }
-    // Previous Session Notes
-    if (task.agentNotes) {
-        lines.push('## Previous Notes');
-        lines.push('');
-        lines.push(task.agentNotes);
-        lines.push('');
-    }
-    // Previous Commits
-    if (task.commits && task.commits.length > 0) {
-        lines.push(`## Previous Commits (${task.commits.length})`);
-        lines.push('');
-        for (const commit of task.commits) {
-            lines.push(`- ${commit.hash.slice(0, 7)}: ${commit.message}`);
-        }
-        lines.push('');
-    }
-    // Project Context Block Index (load-on-demand)
-    if (blockIndices.length > 0) {
-        lines.push('## Available Architecture Context');
-        lines.push('');
-        lines.push('**BEFORE starting work**, load the blocks relevant to your task using the MCP tool:');
-        lines.push('`get_section_block_content(section, blockIds)` — pass the section name and an array of block IDs from the list below.');
-        lines.push('Only load what you need to keep token usage low.');
-        lines.push('');
-        for (const index of blockIndices) {
-            lines.push(`### ${index.section} (${index.totalChars} chars)`);
-            lines.push('');
-            for (const block of index.blocks) {
-                const heading = block.heading ? block.heading.replace(/^#+\s*/, '') : '(intro)';
-                lines.push(`- \`${block.id}\`: ${heading} (${block.charCount} chars)`);
-            }
-            lines.push('');
-        }
-    }
-    // Templates
-    if (templates.length > 0) {
-        lines.push('## Templates Available');
-        lines.push('');
-        for (const template of templates) {
-            const pattern = template.filePattern ? ` (${template.filePattern})` : '';
-            const desc = template.description ? `: ${template.description}` : '';
-            lines.push(`- \`${template.name}\`${pattern}${desc}`);
-        }
-        lines.push('');
-    }
-    // Modules
-    if (modules.length > 0) {
-        lines.push('## Module Structure');
-        lines.push('');
-        for (const mod of modules) {
-            const port = mod.port ? ` (port ${mod.port})` : '';
-            const deps = mod.dependsOn && mod.dependsOn.length > 0 ? ` → ${mod.dependsOn.join(', ')}` : '';
-            lines.push(`- **${mod.name}**: ${mod.path}${port}${deps}`);
-        }
-        lines.push('');
-    }
-    // Linked Feedback
-    if (task.feedback && task.feedback.length > 0) {
-        lines.push('## Linked Feedback (customer requests driving this task)');
-        lines.push('');
-        for (const fb of task.feedback) {
-            lines.push(`- "${fb.title}" (${fb.voterCount} votes)`);
-        }
-        lines.push('');
-    }
-    // Footer
-    lines.push('---');
-    lines.push(`Generated by @damper/cli at ${new Date().toISOString()}.`);
-    lines.push('Re-read this file if conversation context is lost.');
-    return lines.join('\n');
-}