@shepai/cli 1.14.2 → 1.15.1

package/dist/src/presentation/cli/commands/agent/show.command.js

@@ -0,0 +1,202 @@
+/**
+ * Agent Show Command
+ *
+ * Display details of a specific agent run including execution status,
+ * PID, current node, heartbeat, and output.
+ *
+ * Usage:
+ *   shep agent show <id>
+ */
+import { Command } from 'commander';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { colors, messages, symbols, renderDetailView } from '../../ui/index.js';
+import { resolveAgentRun } from './resolve-run.js';
+import { container } from '../../../../infrastructure/di/container.js';
+import { SHEP_HOME_DIR } from '../../../../infrastructure/services/filesystem/shep-directory.service.js';
+function computeWorktreePath(repoPath, branch) {
+    const repoHash = createHash('sha256').update(repoPath).digest('hex').slice(0, 16);
+    const slug = branch.replace(/\//g, '-');
+    return join(SHEP_HOME_DIR, 'repos', repoHash, 'wt', slug);
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createShowCommand() {
+    return new Command('show')
+        .description('Display details of an agent run')
+        .argument('<id>', 'Agent run ID (or prefix)')
+        .action(async (id) => {
+        try {
+            const resolved = await resolveAgentRun(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            const agentRun = resolved.run;
+            const pidAlive = agentRun.pid && (agentRun.status === 'running' || agentRun.status === 'pending')
+                ? isProcessAlive(agentRun.pid)
+                : null;
+            const currentNode = agentRun.status === 'running' && agentRun.result?.startsWith('node:')
+                ? agentRun.result.slice(5)
+                : null;
+            const stuckStatus = getStuckStatus(agentRun);
+            // Resolve worktree path from associated feature
+            let worktreePath = null;
+            let specPath = null;
+            if (agentRun.featureId) {
+                try {
+                    const featureRepo = container.resolve('IFeatureRepository');
+                    const feature = await featureRepo.findById(agentRun.featureId);
+                    if (feature) {
+                        worktreePath = computeWorktreePath(feature.repositoryPath, feature.branch);
+                        specPath = feature.specPath ?? null;
+                    }
+                }
+                catch {
+                    // Feature lookup failed
+                }
+            }
+            // Text blocks for prompt/result/error
+            const textBlocks = [];
+            if (agentRun.prompt) {
+                textBlocks.push({ title: 'Prompt', content: agentRun.prompt });
+            }
+            if (agentRun.result && !agentRun.result.startsWith('node:')) {
+                textBlocks.push({ title: 'Result', content: agentRun.result });
+            }
+            if (agentRun.error) {
+                textBlocks.push({
+                    title: 'Error',
+                    content: agentRun.error,
+                    color: colors.error,
+                });
+            }
+            renderDetailView({
+                title: 'Agent Run',
+                sections: [
+                    {
+                        fields: [
+                            { label: 'ID', value: agentRun.id },
+                            { label: 'Agent', value: agentRun.agentName },
+                            { label: 'Type', value: agentRun.agentType },
+                            { label: 'Status', value: formatStatus(agentRun, pidAlive) },
+                            { label: 'Node', value: currentNode ? colors.info(currentNode) : null },
+                            { label: 'PID', value: formatPid(agentRun, pidAlive) },
+                            { label: 'Thread', value: agentRun.threadId },
+                        ],
+                    },
+                    {
+                        title: 'Paths',
+                        fields: [
+                            { label: 'Worktree', value: worktreePath },
+                            { label: 'Spec Dir', value: specPath },
+                        ],
+                    },
+                    {
+                        title: 'Timing',
+                        fields: [
+                            { label: 'Started', value: formatDate(agentRun.startedAt) },
+                            { label: 'Completed', value: formatDate(agentRun.completedAt) },
+                            { label: 'Duration', value: getDurationString(agentRun) },
+                            { label: 'Heartbeat', value: formatDate(agentRun.lastHeartbeat) },
+                            { label: 'Created', value: formatDate(agentRun.createdAt) },
+                            { label: 'Updated', value: formatDate(agentRun.updatedAt) },
+                            { label: 'Warning', value: stuckStatus },
+                        ],
+                    },
+                ],
+                textBlocks,
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to show agent run', err);
+            process.exitCode = 1;
+        }
+    });
+}
+function formatStatus(agentRun, pidAlive) {
+    const isActive = agentRun.status === 'running' || agentRun.status === 'pending';
+    if (isActive && pidAlive === false) {
+        return `${colors.error(symbols.error)} ${colors.error('crashed')}`;
+    }
+    const map = {
+        pending: `${colors.muted(symbols.dotEmpty)} ${colors.muted('pending')}`,
+        running: `${colors.info(symbols.dot)} ${colors.info('running')}`,
+        completed: `${colors.success(symbols.success)} ${colors.success('completed')}`,
+        failed: `${colors.error(symbols.error)} ${colors.error('failed')}`,
+        interrupted: `${colors.error(symbols.error)} ${colors.error('interrupted')}`,
+        cancelled: `${colors.muted(symbols.dotEmpty)} ${colors.muted('cancelled')}`,
+    };
+    return map[agentRun.status] || colors.muted(agentRun.status);
+}
+function formatPid(agentRun, pidAlive) {
+    if (!agentRun.pid)
+        return colors.muted('-');
+    const pidStr = String(agentRun.pid);
+    if (pidAlive === true)
+        return `${pidStr} ${colors.success('(alive)')}`;
+    if (pidAlive === false)
+        return `${pidStr} ${colors.error('(dead)')}`;
+    return pidStr;
+}
+function formatDate(date) {
+    if (!date)
+        return null;
+    try {
+        return new Date(date).toLocaleString();
+    }
+    catch {
+        return date;
+    }
+}
+function getDurationString(agentRun) {
+    if (agentRun.status === 'pending') {
+        const ms = Date.now() - new Date(agentRun.createdAt).getTime();
+        return `${formatDuration(ms)} ${colors.error('(stuck in pending)')}`;
+    }
+    if (agentRun.startedAt && agentRun.completedAt) {
+        return formatDuration(new Date(agentRun.completedAt).getTime() - new Date(agentRun.startedAt).getTime());
+    }
+    if (agentRun.startedAt) {
+        const ms = Date.now() - new Date(agentRun.startedAt).getTime();
+        return `${formatDuration(ms)} ${colors.info('(running)')}`;
+    }
+    return '-';
+}
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h ${minutes % 60}m`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}
+function getStuckStatus(agentRun) {
+    if (agentRun.status === 'pending' && !agentRun.startedAt) {
+        const hours = (Date.now() - new Date(agentRun.createdAt).getTime()) / (1000 * 60 * 60);
+        if (hours > 24)
+            return colors.error(`STUCK: Pending for ${Math.floor(hours)} hours. Check agent logs.`);
+        if (hours > 1)
+            return colors.error(`WARNING: Pending for ${Math.floor(hours)} hour(s).`);
+    }
+    if (agentRun.status === 'running' && agentRun.startedAt) {
+        const hours = (Date.now() - new Date(agentRun.startedAt).getTime()) / (1000 * 60 * 60);
+        if (hours > 24)
+            return colors.error(`STUCK: Running for ${Math.floor(hours)} hours. Process may have crashed.`);
+    }
+    return null;
+}

package/dist/src/presentation/cli/commands/agent/stop.command.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agent Stop Command
+ *
+ * Sends SIGTERM to a running agent and marks it as cancelled.
+ *
+ * Usage:
+ *   shep agent stop <id>
+ */
+import { Command } from 'commander';
+export declare function createStopCommand(): Command;
+//# sourceMappingURL=stop.command.d.ts.map

package/dist/src/presentation/cli/commands/agent/stop.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/agent/stop.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMpC,wBAAgB,iBAAiB,IAAI,OAAO,CA8B3C"}

package/dist/src/presentation/cli/commands/agent/stop.command.js

@@ -0,0 +1,42 @@
+/**
+ * Agent Stop Command
+ *
+ * Sends SIGTERM to a running agent and marks it as cancelled.
+ *
+ * Usage:
+ *   shep agent stop <id>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { StopAgentRunUseCase } from '../../../../application/use-cases/agents/stop-agent-run.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { resolveAgentRun } from './resolve-run.js';
+export function createStopCommand() {
+    return new Command('stop')
+        .description('Stop a running agent')
+        .argument('<id>', 'Agent run ID (or prefix)')
+        .action(async (id) => {
+        try {
+            const resolved = await resolveAgentRun(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            const useCase = container.resolve(StopAgentRunUseCase);
+            const result = await useCase.execute(resolved.run.id);
+            if (result.stopped) {
+                messages.success(`Stopped ${colors.accent(resolved.run.id.substring(0, 8))}: ${result.reason}`);
+            }
+            else {
+                messages.error(result.reason);
+                process.exitCode = 1;
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to stop agent run', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/del.command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Feature Delete Command
+ *
+ * Deletes a feature, its worktree, and cancels any running agent.
+ *
+ * Usage: shep feat del <id> [--force]
+ *
+ * @example
+ * $ shep feat del feat-123
+ * $ shep feat del feat-123 --force
+ */
+import { Command } from 'commander';
+/**
+ * Create the feat del command
+ */
+export declare function createDelCommand(): Command;
+//# sourceMappingURL=del.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/del.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"del.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/del.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAoC1C"}

package/dist/src/presentation/cli/commands/feat/del.command.js

@@ -0,0 +1,55 @@
+/**
+ * Feature Delete Command
+ *
+ * Deletes a feature, its worktree, and cancels any running agent.
+ *
+ * Usage: shep feat del <id> [--force]
+ *
+ * @example
+ * $ shep feat del feat-123
+ * $ shep feat del feat-123 --force
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { DeleteFeatureUseCase } from '../../../../application/use-cases/features/delete-feature.use-case.js';
+import { ShowFeatureUseCase } from '../../../../application/use-cases/features/show-feature.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { confirm } from '@inquirer/prompts';
+/**
+ * Create the feat del command
+ */
+export function createDelCommand() {
+    return new Command('del')
+        .description('Delete a feature')
+        .argument('<id>', 'Feature ID or prefix')
+        .option('-f, --force', 'Skip confirmation prompt')
+        .action(async (featureId, options) => {
+        try {
+            // First show what we're about to delete
+            const showUseCase = container.resolve(ShowFeatureUseCase);
+            const feature = await showUseCase.execute(featureId);
+            if (!options.force) {
+                const confirmed = await confirm({
+                    message: `Delete feature "${feature.name}"?`,
+                    default: false,
+                });
+                if (!confirmed) {
+                    messages.info('Cancelled');
+                    return;
+                }
+            }
+            const deleteUseCase = container.resolve(DeleteFeatureUseCase);
+            await deleteUseCase.execute(feature.id);
+            messages.newline();
+            messages.success('Feature deleted');
+            console.log(`  ${colors.muted('Name:')}   ${feature.name}`);
+            console.log(`  ${colors.muted('Branch:')} ${feature.branch}`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to delete feature', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Feature Command Group
+ *
+ * Provides subcommands for managing features through the SDLC lifecycle.
+ *
+ * Usage:
+ *   shep feat new <description>  # Create a new feature
+ *   shep feat ls                 # List features
+ *   shep feat show <id>          # Show feature details
+ *   shep feat del <id>           # Delete a feature
+ */
+import { Command } from 'commander';
+/**
+ * Create the feat command group
+ */
+export declare function createFeatCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/presentation/cli/commands/feat/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAQ3C"}

package/dist/src/presentation/cli/commands/feat/index.js

@@ -0,0 +1,29 @@
+/**
+ * Feature Command Group
+ *
+ * Provides subcommands for managing features through the SDLC lifecycle.
+ *
+ * Usage:
+ *   shep feat new <description>  # Create a new feature
+ *   shep feat ls                 # List features
+ *   shep feat show <id>          # Show feature details
+ *   shep feat del <id>           # Delete a feature
+ */
+import { Command } from 'commander';
+import { createNewCommand } from './new.command.js';
+import { createLsCommand } from './ls.command.js';
+import { createShowCommand } from './show.command.js';
+import { createDelCommand } from './del.command.js';
+import { createResumeCommand } from './resume.command.js';
+/**
+ * Create the feat command group
+ */
+export function createFeatCommand() {
+    return new Command('feat')
+        .description('Manage features through the SDLC lifecycle')
+        .addCommand(createNewCommand())
+        .addCommand(createLsCommand())
+        .addCommand(createShowCommand())
+        .addCommand(createDelCommand())
+        .addCommand(createResumeCommand());
+}

package/dist/src/presentation/cli/commands/feat/ls.command.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Feature List Command
+ *
+ * Lists features in a formatted list with optional filtering.
+ * Derives real-time status from the agent run (not stale Feature.lifecycle).
+ *
+ * Usage: shep feat ls [options]
+ *
+ * @example
+ * $ shep feat ls
+ * $ shep feat ls --repo /path/to/project
+ */
+import { Command } from 'commander';
+export declare function createLsCommand(): Command;
+//# sourceMappingURL=ls.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/ls.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ls.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/ls.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoEpC,wBAAgB,eAAe,IAAI,OAAO,CAqDzC"}

package/dist/src/presentation/cli/commands/feat/ls.command.js

@@ -0,0 +1,112 @@
+/**
+ * Feature List Command
+ *
+ * Lists features in a formatted list with optional filtering.
+ * Derives real-time status from the agent run (not stale Feature.lifecycle).
+ *
+ * Usage: shep feat ls [options]
+ *
+ * @example
+ * $ shep feat ls
+ * $ shep feat ls --repo /path/to/project
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { ListFeaturesUseCase } from '../../../../application/use-cases/features/list-features.use-case.js';
+import { colors, symbols, messages, renderListView } from '../../ui/index.js';
+/** Map graph node names to human-readable phase labels. */
+const NODE_TO_PHASE = {
+    analyze: 'Analyzing',
+    requirements: 'Requirements',
+    research: 'Researching',
+    plan: 'Planning',
+    implement: 'Implementing',
+};
+/**
+ * Derive the display status from the agent run.
+ * Returns the current graph node as a phase label with an activity indicator.
+ */
+function formatStatus(feature, run) {
+    if (!run) {
+        // No agent run — fall back to static lifecycle
+        return `${colors.muted(symbols.dotEmpty)} ${colors.muted(feature.lifecycle)}`;
+    }
+    const isRunning = run.status === 'running' || run.status === 'pending';
+    const phase = run.result?.startsWith('node:')
+        ? (NODE_TO_PHASE[run.result.slice(5)] ?? run.result.slice(5))
+        : feature.lifecycle;
+    if (isRunning) {
+        // Check PID liveness for running agents
+        if (run.pid && !isProcessAlive(run.pid)) {
+            return `${colors.error(symbols.error)} ${colors.error('crashed')}`;
+        }
+        return `${colors.info(symbols.spinner[0])} ${colors.info(phase)}`;
+    }
+    if (run.status === 'completed') {
+        return `${colors.success(symbols.success)} ${colors.success('Completed')}`;
+    }
+    if (run.status === 'failed') {
+        return `${colors.error(symbols.error)} ${colors.error('Failed')}`;
+    }
+    if (run.status === 'waiting_approval') {
+        return `${colors.warning(symbols.warning)} ${colors.warning(phase)}`;
+    }
+    if (run.status === 'interrupted') {
+        return `${colors.error(symbols.error)} ${colors.error('Interrupted')}`;
+    }
+    return `${colors.muted(symbols.dotEmpty)} ${colors.muted(phase)}`;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function createLsCommand() {
+    return new Command('ls')
+        .description('List features')
+        .option('-r, --repo <path>', 'Filter by repository path')
+        .action(async (options) => {
+        try {
+            const useCase = container.resolve(ListFeaturesUseCase);
+            const runRepo = container.resolve('IAgentRunRepository');
+            const filters = options.repo ? { repositoryPath: options.repo } : undefined;
+            const features = await useCase.execute(filters);
+            // Load agent runs for all features in parallel
+            const runs = await Promise.all(features.map((f) => f.agentRunId ? runRepo.findById(f.agentRunId) : Promise.resolve(null)));
+            const rows = features.map((feature, i) => {
+                const run = runs[i];
+                const updated = feature.updatedAt instanceof Date
+                    ? feature.updatedAt.toLocaleDateString()
+                    : String(feature.updatedAt);
+                return [
+                    feature.id.slice(0, 8),
+                    feature.name.slice(0, 30),
+                    formatStatus(feature, run),
+                    colors.muted(feature.branch),
+                    colors.muted(updated),
+                ];
+            });
+            renderListView({
+                title: 'Features',
+                columns: [
+                    { label: 'ID', width: 10 },
+                    { label: 'Name', width: 32 },
+                    { label: 'Status', width: 20 },
+                    { label: 'Branch', width: 28 },
+                    { label: 'Updated', width: 12 },
+                ],
+                rows,
+                emptyMessage: 'No features found',
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to list features', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/new.command.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Feature New Command
+ *
+ * Creates a new feature with a git branch and worktree.
+ *
+ * Usage: shep feat new <description> [options]
+ *
+ * @example
+ * $ shep feat new "Add user authentication"
+ * $ shep feat new "Add login page" --repo /path/to/project
+ */
+import { Command } from 'commander';
+/**
+ * Create the feat new command
+ */
+export declare function createNewCommand(): Command;
+//# sourceMappingURL=new.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/new.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CA6C1C"}

package/dist/src/presentation/cli/commands/feat/new.command.js

@@ -0,0 +1,64 @@
+/**
+ * Feature New Command
+ *
+ * Creates a new feature with a git branch and worktree.
+ *
+ * Usage: shep feat new <description> [options]
+ *
+ * @example
+ * $ shep feat new "Add user authentication"
+ * $ shep feat new "Add login page" --repo /path/to/project
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { CreateFeatureUseCase } from '../../../../application/use-cases/features/create-feature.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+/**
+ * Create the feat new command
+ */
+export function createNewCommand() {
+    return new Command('new')
+        .description('Create a new feature')
+        .argument('<description>', 'Feature description')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .option('--interactive', 'Require approval after every agent step')
+        .option('--allow-prd', 'Auto-approve through requirements, pause after')
+        .option('--allow-plan', 'Auto-approve through planning, pause at implementation')
+        .option('--allow-all', 'Run fully autonomous (no approval pauses)')
+        .action(async (description, options) => {
+        try {
+            const useCase = container.resolve(CreateFeatureUseCase);
+            const repoPath = options.repo ?? process.cwd();
+            // Determine approval mode from flags (last one wins if multiple specified)
+            let approvalMode;
+            if (options.interactive)
+                approvalMode = 'interactive';
+            if (options.allowPrd)
+                approvalMode = 'allow-prd';
+            if (options.allowPlan)
+                approvalMode = 'allow-plan';
+            if (options.allowAll)
+                approvalMode = 'allow-all';
+            const feature = await useCase.execute({
+                userInput: description,
+                repositoryPath: repoPath,
+                approvalMode,
+            });
+            messages.newline();
+            messages.success('Feature created');
+            console.log(`  ${colors.muted('ID:')}     ${colors.accent(feature.id)}`);
+            console.log(`  ${colors.muted('Name:')}   ${feature.name}`);
+            console.log(`  ${colors.muted('Branch:')} ${colors.accent(feature.branch)}`);
+            console.log(`  ${colors.muted('Status:')} ${feature.lifecycle}`);
+            if (feature.agentRunId) {
+                console.log(`  ${colors.muted('Agent:')}  ${colors.success('spawned')} (run ${feature.agentRunId.slice(0, 8)})`);
+            }
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to create feature', err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/feat/resume.command.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Feature Resume Command
+ *
+ * Resumes an interrupted or failed feature agent run.
+ *
+ * Usage:
+ *   shep feat resume <id>
+ */
+import { Command } from 'commander';
+export declare function createResumeCommand(): Command;
+//# sourceMappingURL=resume.command.d.ts.map

package/dist/src/presentation/cli/commands/feat/resume.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/resume.command.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,mBAAmB,IAAI,OAAO,CAoB7C"}

package/dist/src/presentation/cli/commands/feat/resume.command.js

@@ -0,0 +1,33 @@
+/**
+ * Feature Resume Command
+ *
+ * Resumes an interrupted or failed feature agent run.
+ *
+ * Usage:
+ *   shep feat resume <id>
+ */
+import { Command } from 'commander';
+import { container } from '../../../../infrastructure/di/container.js';
+import { ResumeFeatureUseCase } from '../../../../application/use-cases/features/resume-feature.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+export function createResumeCommand() {
+    return new Command('resume')
+        .description('Resume a stopped or failed feature agent')
+        .argument('<id>', 'Feature ID (or prefix)')
+        .action(async (id) => {
+        try {
+            const useCase = container.resolve(ResumeFeatureUseCase);
+            const { feature, newRun } = await useCase.execute(id);
+            messages.newline();
+            messages.success('Feature agent resumed');
+            console.log(`  ${colors.muted('Feature:')} ${feature.name}`);
+            console.log(`  ${colors.muted('Run ID:')}  ${colors.accent(newRun.id.substring(0, 8))}`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to resume feature', err);
+            process.exitCode = 1;
+        }
+    });
+}