Tm start (#1200)

Co-authored-by: Max Tuzzolino <maxtuzz@Maxs-MacBook-Pro.local>
Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Max Tuzzolino <max.tuzsmith@gmail.com>
Co-authored-by: Ralph Khreish <35776126+Crunchyman-ralph@users.noreply.github.com>

apps/cli/src/commands/show.command.ts

@@ -9,14 +9,7 @@ import boxen from 'boxen';
 import { createTaskMasterCore, type Task, type TaskMasterCore } from '@tm/core';
 import type { StorageType } from '@tm/core/types';
 import * as ui from '../utils/ui.js';
-import {
-	displayTaskHeader,
-	displayTaskProperties,
-	displayImplementationDetails,
-	displayTestStrategy,
-	displaySubtasks,
-	displaySuggestedActions
-} from '../ui/components/task-detail.component.js';
+import { displayTaskDetails } from '../ui/components/task-detail.component.js';
 
 /**
  * Options interface for the show command
@@ -264,44 +257,11 @@ export class ShowCommand extends Command {
 			return;
 		}
 
-		const task = result.task;
-
-		// Display header with tag
-		displayTaskHeader(task.id, task.title);
-
-		// Display task properties in table format
-		displayTaskProperties(task);
-
-		// Display implementation details if available
-		if (task.details) {
-			console.log(); // Empty line for spacing
-			displayImplementationDetails(task.details);
-		}
-
-		// Display test strategy if available
-		if ('testStrategy' in task && task.testStrategy) {
-			console.log(); // Empty line for spacing
-			displayTestStrategy(task.testStrategy as string);
-		}
-
-		// Display subtasks if available
-		if (task.subtasks && task.subtasks.length > 0) {
-			// Filter subtasks by status if provided
-			const filteredSubtasks = options.status
-				? task.subtasks.filter((sub) => sub.status === options.status)
-				: task.subtasks;
-
-			if (filteredSubtasks.length === 0 && options.status) {
-				console.log(
-					chalk.gray(`  No subtasks with status '${options.status}'`)
-				);
-			} else {
-				displaySubtasks(filteredSubtasks, task.id);
-			}
-		}
-
-		// Display suggested actions
-		displaySuggestedActions(task.id);
+		// Use the global task details display function
+		displayTaskDetails(result.task, {
+			statusFilter: options.status,
+			showSuggestedActions: true
+		});
 	}
 
 	/**

apps/cli/src/commands/start.command.ts

@@ -0,0 +1,512 @@
+/**
+ * @fileoverview StartCommand using Commander's native class pattern
+ * Extends Commander.Command for better integration with the framework
+ * This is a thin presentation layer over @tm/core's TaskExecutionService
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import boxen from 'boxen';
+import ora, { type Ora } from 'ora';
+import { spawn } from 'child_process';
+import {
+	createTaskMasterCore,
+	type TaskMasterCore,
+	type StartTaskResult as CoreStartTaskResult
+} from '@tm/core';
+import { displayTaskDetails } from '../ui/components/task-detail.component.js';
+import * as ui from '../utils/ui.js';
+
+/**
+ * CLI-specific options interface for the start command
+ */
+export interface StartCommandOptions {
+	id?: string;
+	format?: 'text' | 'json';
+	project?: string;
+	dryRun?: boolean;
+	force?: boolean;
+	noStatusUpdate?: boolean;
+}
+
+/**
+ * CLI-specific result type from start command
+ * Extends the core result with CLI-specific display information
+ */
+export interface StartCommandResult extends CoreStartTaskResult {
+	storageType?: string;
+}
+
+/**
+ * StartCommand extending Commander's Command class
+ * This is a thin presentation layer over @tm/core's TaskExecutionService
+ */
+export class StartCommand extends Command {
+	private tmCore?: TaskMasterCore;
+	private lastResult?: StartCommandResult;
+
+	constructor(name?: string) {
+		super(name || 'start');
+
+		// Configure the command
+		this.description(
+			'Start working on a task by launching claude-code with context'
+		)
+			.argument('[id]', 'Task ID to start working on')
+			.option('-i, --id <id>', 'Task ID to start working on')
+			.option('-f, --format <format>', 'Output format (text, json)', 'text')
+			.option('-p, --project <path>', 'Project root directory', process.cwd())
+			.option(
+				'--dry-run',
+				'Show what would be executed without launching claude-code'
+			)
+			.option(
+				'--force',
+				'Force start even if another task is already in-progress'
+			)
+			.option(
+				'--no-status-update',
+				'Do not automatically update task status to in-progress'
+			)
+			.action(
+				async (taskId: string | undefined, options: StartCommandOptions) => {
+					await this.executeCommand(taskId, options);
+				}
+			);
+	}
+
+	/**
+	 * Execute the start command
+	 */
+	private async executeCommand(
+		taskId: string | undefined,
+		options: StartCommandOptions
+	): Promise<void> {
+		let spinner: Ora | null = null;
+
+		try {
+			// Validate options
+			if (!this.validateOptions(options)) {
+				process.exit(1);
+			}
+
+			// Initialize tm-core with spinner
+			spinner = ora('Initializing Task Master...').start();
+			await this.initializeCore(options.project || process.cwd());
+			spinner.succeed('Task Master initialized');
+
+			// Get the task ID from argument or option, or find next available task
+			const idArg = taskId || options.id || null;
+			let targetTaskId = idArg;
+
+			if (!targetTaskId) {
+				spinner = ora('Finding next available task...').start();
+				targetTaskId = await this.performGetNextTask();
+				if (targetTaskId) {
+					spinner.succeed(`Found next task: #${targetTaskId}`);
+				} else {
+					spinner.fail('No available tasks found');
+				}
+			}
+
+			if (!targetTaskId) {
+				ui.displayError('No task ID provided and no available tasks found');
+				process.exit(1);
+			}
+
+			// Show pre-launch message (no spinner needed, it's just display)
+			if (!options.dryRun) {
+				await this.showPreLaunchMessage(targetTaskId);
+			}
+
+			// Use tm-core's startTask method with spinner
+			spinner = ora('Preparing task execution...').start();
+			const coreResult = await this.performStartTask(targetTaskId, options);
+
+			if (coreResult.started) {
+				spinner.succeed(
+					options.dryRun
+						? 'Dry run completed'
+						: 'Task prepared - launching Claude...'
+				);
+			} else {
+				spinner.fail('Task execution failed');
+			}
+
+			// Execute command if we have one and it's not a dry run
+			if (!options.dryRun && coreResult.command) {
+				// Stop any remaining spinners before launching Claude
+				if (spinner && !spinner.isSpinning) {
+					// Clear the line to make room for Claude
+					console.log();
+				}
+				await this.executeChildProcess(coreResult.command);
+			}
+
+			// Convert core result to CLI result with storage type
+			const result: StartCommandResult = {
+				...coreResult,
+				storageType: this.tmCore?.getStorageType()
+			};
+
+			// Store result for programmatic access
+			this.setLastResult(result);
+
+			// Display results (only for dry run or if execution failed)
+			if (options.dryRun || !coreResult.started) {
+				this.displayResults(result, options);
+			}
+		} catch (error: any) {
+			if (spinner) {
+				spinner.fail('Operation failed');
+			}
+			this.handleError(error);
+			process.exit(1);
+		}
+	}
+
+	/**
+	 * Validate command options
+	 */
+	private validateOptions(options: StartCommandOptions): boolean {
+		// Validate format
+		if (options.format && !['text', 'json'].includes(options.format)) {
+			console.error(chalk.red(`Invalid format: ${options.format}`));
+			console.error(chalk.gray(`Valid formats: text, json`));
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Initialize TaskMasterCore
+	 */
+	private async initializeCore(projectRoot: string): Promise<void> {
+		if (!this.tmCore) {
+			this.tmCore = await createTaskMasterCore({ projectPath: projectRoot });
+		}
+	}
+
+	/**
+	 * Get the next available task using tm-core
+	 */
+	private async performGetNextTask(): Promise<string | null> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+		return this.tmCore.getNextAvailableTask();
+	}
+
+	/**
+	 * Show pre-launch message using tm-core data
+	 */
+	private async showPreLaunchMessage(targetTaskId: string): Promise<void> {
+		if (!this.tmCore) return;
+
+		const { task, subtask, subtaskId } =
+			await this.tmCore.getTaskWithSubtask(targetTaskId);
+		if (task) {
+			const workItemText = subtask
+				? `Subtask #${task.id}.${subtaskId} - ${subtask.title}`
+				: `Task #${task.id} - ${task.title}`;
+
+			console.log(
+				chalk.green('🚀 Starting: ') + chalk.white.bold(workItemText)
+			);
+			console.log(chalk.gray('Launching Claude Code...'));
+			console.log(); // Empty line
+		}
+	}
+
+	/**
+	 * Perform start task using tm-core business logic
+	 */
+	private async performStartTask(
+		targetTaskId: string,
+		options: StartCommandOptions
+	): Promise<CoreStartTaskResult> {
+		if (!this.tmCore) {
+			throw new Error('TaskMasterCore not initialized');
+		}
+
+		// Show spinner for status update if enabled
+		let statusSpinner: Ora | null = null;
+		if (!options.noStatusUpdate && !options.dryRun) {
+			statusSpinner = ora('Updating task status to in-progress...').start();
+		}
+
+		// Get execution command from tm-core (instead of executing directly)
+		const result = await this.tmCore.startTask(targetTaskId, {
+			dryRun: options.dryRun,
+			force: options.force,
+			updateStatus: !options.noStatusUpdate
+		});
+
+		if (statusSpinner) {
+			if (result.started) {
+				statusSpinner.succeed('Task status updated');
+			} else {
+				statusSpinner.warn('Task status update skipped');
+			}
+		}
+
+		if (!result) {
+			throw new Error('Failed to start task - core result is undefined');
+		}
+
+		// Don't execute here - let the main executeCommand method handle it
+		return result;
+	}
+
+	/**
+	 * Execute the child process directly in the main thread for better process control
+	 */
+	private async executeChildProcess(command: {
+		executable: string;
+		args: string[];
+		cwd: string;
+	}): Promise<void> {
+		return new Promise((resolve, reject) => {
+			// Don't show the full command with args as it can be very long
+			console.log(chalk.green('🚀 Launching Claude Code...'));
+			console.log(); // Add space before Claude takes over
+
+			const childProcess = spawn(command.executable, command.args, {
+				cwd: command.cwd,
+				stdio: 'inherit', // Inherit stdio from parent process
+				shell: false
+			});
+
+			childProcess.on('close', (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(new Error(`Process exited with code ${code}`));
+				}
+			});
+
+			childProcess.on('error', (error) => {
+				reject(new Error(`Failed to spawn process: ${error.message}`));
+			});
+
+			// Handle process termination signals gracefully
+			const cleanup = () => {
+				if (childProcess && !childProcess.killed) {
+					childProcess.kill('SIGTERM');
+				}
+			};
+
+			process.on('SIGINT', cleanup);
+			process.on('SIGTERM', cleanup);
+			process.on('exit', cleanup);
+		});
+	}
+
+	/**
+	 * Display results based on format
+	 */
+	private displayResults(
+		result: StartCommandResult,
+		options: StartCommandOptions
+	): void {
+		const format = options.format || 'text';
+
+		switch (format) {
+			case 'json':
+				this.displayJson(result);
+				break;
+
+			case 'text':
+			default:
+				this.displayTextResult(result, options);
+				break;
+		}
+	}
+
+	/**
+	 * Display in JSON format
+	 */
+	private displayJson(result: StartCommandResult): void {
+		console.log(JSON.stringify(result, null, 2));
+	}
+
+	/**
+	 * Display result in text format
+	 */
+	private displayTextResult(
+		result: StartCommandResult,
+		options: StartCommandOptions
+	): void {
+		if (!result.found || !result.task) {
+			console.log(
+				boxen(chalk.yellow(`Task not found!`), {
+					padding: { top: 0, bottom: 0, left: 1, right: 1 },
+					borderColor: 'yellow',
+					borderStyle: 'round',
+					margin: { top: 1 }
+				})
+			);
+			return;
+		}
+
+		const task = result.task;
+
+		if (options.dryRun) {
+			// For dry run, show full details since Claude Code won't be launched
+			let headerText = `Dry Run: Starting Task #${task.id} - ${task.title}`;
+
+			// If working on a specific subtask, highlight it in the header
+			if (result.subtask && result.subtaskId) {
+				headerText = `Dry Run: Starting Subtask #${task.id}.${result.subtaskId} - ${result.subtask.title}`;
+			}
+
+			displayTaskDetails(task, {
+				customHeader: headerText,
+				headerColor: 'yellow'
+			});
+
+			// Show claude-code prompt
+			if (result.executionOutput) {
+				console.log(); // Empty line for spacing
+				console.log(
+					boxen(
+						chalk.white.bold('Claude-Code Prompt:') +
+							'\n\n' +
+							result.executionOutput,
+						{
+							padding: 1,
+							borderStyle: 'round',
+							borderColor: 'cyan',
+							width: process.stdout.columns * 0.95 || 100
+						}
+					)
+				);
+			}
+
+			console.log(); // Empty line for spacing
+			console.log(
+				boxen(
+					chalk.yellow(
+						'🔍 Dry run - claude-code would be launched with the above prompt'
+					),
+					{
+						padding: { top: 0, bottom: 0, left: 1, right: 1 },
+						borderColor: 'yellow',
+						borderStyle: 'round'
+					}
+				)
+			);
+		} else {
+			// For actual execution, show minimal info since Claude Code will clear the terminal
+			if (result.started) {
+				// Determine what was worked on - task or subtask
+				let workItemText = `Task: #${task.id} - ${task.title}`;
+				let statusTarget = task.id;
+
+				if (result.subtask && result.subtaskId) {
+					workItemText = `Subtask: #${task.id}.${result.subtaskId} - ${result.subtask.title}`;
+					statusTarget = `${task.id}.${result.subtaskId}`;
+				}
+
+				// Post-execution message (shown after Claude Code exits)
+				console.log(
+					boxen(
+						chalk.green.bold('🎉 Task Session Complete!') +
+							'\n\n' +
+							chalk.white(workItemText) +
+							'\n\n' +
+							chalk.cyan('Next steps:') +
+							'\n' +
+							`• Run ${chalk.yellow('tm show ' + task.id)} to review task details\n` +
+							`• Run ${chalk.yellow('tm set-status --id=' + statusTarget + ' --status=done')} when complete\n` +
+							`• Run ${chalk.yellow('tm next')} to find the next available task\n` +
+							`• Run ${chalk.yellow('tm start')} to begin the next task`,
+						{
+							padding: 1,
+							borderStyle: 'round',
+							borderColor: 'green',
+							width: process.stdout.columns * 0.95 || 100,
+							margin: { top: 1 }
+						}
+					)
+				);
+			} else {
+				// Error case
+				console.log(
+					boxen(
+						chalk.red(
+							'❌ Failed to launch claude-code' +
+								(result.error ? `\nError: ${result.error}` : '')
+						),
+						{
+							padding: { top: 0, bottom: 0, left: 1, right: 1 },
+							borderColor: 'red',
+							borderStyle: 'round'
+						}
+					)
+				);
+			}
+		}
+
+		console.log(`\n${chalk.gray('Storage: ' + result.storageType)}`);
+	}
+
+	/**
+	 * Handle general errors
+	 */
+	private handleError(error: any): void {
+		const msg = error?.getSanitizedDetails?.() ?? {
+			message: error?.message ?? String(error)
+		};
+		console.error(chalk.red(`Error: ${msg.message || 'Unexpected error'}`));
+
+		// Show stack trace in development mode or when DEBUG is set
+		const isDevelopment = process.env.NODE_ENV !== 'production';
+		if ((isDevelopment || process.env.DEBUG) && error.stack) {
+			console.error(chalk.gray(error.stack));
+		}
+	}
+
+	/**
+	 * Set the last result for programmatic access
+	 */
+	private setLastResult(result: StartCommandResult): void {
+		this.lastResult = result;
+	}
+
+	/**
+	 * Get the last result (for programmatic usage)
+	 */
+	getLastResult(): StartCommandResult | undefined {
+		return this.lastResult;
+	}
+
+	/**
+	 * Clean up resources
+	 */
+	async cleanup(): Promise<void> {
+		if (this.tmCore) {
+			await this.tmCore.close();
+			this.tmCore = undefined;
+		}
+	}
+
+	/**
+	 * Static method to register this command on an existing program
+	 */
+	static registerOn(program: Command): Command {
+		const startCommand = new StartCommand();
+		program.addCommand(startCommand);
+		return startCommand;
+	}
+
+	/**
+	 * Alternative registration that returns the command for chaining
+	 */
+	static register(program: Command, name?: string): StartCommand {
+		const startCommand = new StartCommand(name);
+		program.addCommand(startCommand);
+		return startCommand;
+	}
+}

apps/cli/src/index.ts

@@ -8,6 +8,7 @@ export { ListTasksCommand } from './commands/list.command.js';
 export { ShowCommand } from './commands/show.command.js';
 export { AuthCommand } from './commands/auth.command.js';
 export { ContextCommand } from './commands/context.command.js';
+export { StartCommand } from './commands/start.command.js';
 export { SetStatusCommand } from './commands/set-status.command.js';
 
 // UI utilities (for other commands to use)

apps/cli/src/ui/components/task-detail.component.ts

@@ -262,3 +262,74 @@ export function displaySuggestedActions(taskId: string | number): void {
 		)
 	);
 }
+
+/**
+ * Display complete task details - used by both show and start commands
+ */
+export function displayTaskDetails(
+	task: Task,
+	options?: {
+		statusFilter?: string;
+		showSuggestedActions?: boolean;
+		customHeader?: string;
+		headerColor?: string;
+	}
+): void {
+	const {
+		statusFilter,
+		showSuggestedActions = false,
+		customHeader,
+		headerColor = 'blue'
+	} = options || {};
+
+	// Display header - either custom or default
+	if (customHeader) {
+		console.log(
+			boxen(chalk.white.bold(customHeader), {
+				padding: { top: 0, bottom: 0, left: 1, right: 1 },
+				borderColor: headerColor,
+				borderStyle: 'round',
+				margin: { top: 1 }
+			})
+		);
+	} else {
+		displayTaskHeader(task.id, task.title);
+	}
+
+	// Display task properties in table format
+	displayTaskProperties(task);
+
+	// Display implementation details if available
+	if (task.details) {
+		console.log(); // Empty line for spacing
+		displayImplementationDetails(task.details);
+	}
+
+	// Display test strategy if available
+	if ('testStrategy' in task && task.testStrategy) {
+		console.log(); // Empty line for spacing
+		displayTestStrategy(task.testStrategy as string);
+	}
+
+	// Display subtasks if available
+	if (task.subtasks && task.subtasks.length > 0) {
+		// Filter subtasks by status if provided
+		const filteredSubtasks = statusFilter
+			? task.subtasks.filter((sub) => sub.status === statusFilter)
+			: task.subtasks;
+
+		if (filteredSubtasks.length === 0 && statusFilter) {
+			console.log(); // Empty line for spacing
+			console.log(chalk.gray(`  No subtasks with status '${statusFilter}'`));
+		} else if (filteredSubtasks.length > 0) {
+			console.log(); // Empty line for spacing
+			displaySubtasks(filteredSubtasks, task.id);
+		}
+	}
+
+	// Display suggested actions if requested
+	if (showSuggestedActions) {
+		console.log(); // Empty line for spacing
+		displaySuggestedActions(task.id);
+	}
+}

apps/extension/src/components/TaskDetails/TaskMetadataSidebar.tsx

@@ -11,7 +11,6 @@ interface TaskMetadataSidebarProps {
 	tasks: TaskMasterTask[];
 	complexity: any;
 	isSubtask: boolean;
-	sendMessage: (message: any) => Promise<any>;
 	onStatusChange: (status: TaskMasterTask['status']) => void;
 	onDependencyClick: (depId: string) => void;
 	isRegenerating?: boolean;
@@ -23,13 +22,12 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 	tasks,
 	complexity,
 	isSubtask,
-	sendMessage,
 	onStatusChange,
 	onDependencyClick,
 	isRegenerating = false,
 	isAppending = false
 }) => {
-	const { vscode } = useVSCodeContext();
+	const { sendMessage } = useVSCodeContext();
 	const [isLoadingComplexity, setIsLoadingComplexity] = useState(false);
 	const [mcpComplexityScore, setMcpComplexityScore] = useState<
 		number | undefined
@@ -101,26 +99,37 @@ export const TaskMetadataSidebar: React.FC<TaskMetadataSidebarProps> = ({
 	};
 
 	// Handle starting a task
-	const handleStartTask = () => {
+	const handleStartTask = async () => {
 		if (!currentTask || isStartingTask) {
 			return;
 		}
 
 		setIsStartingTask(true);
 
-		// Send message to extension to open terminal
-		if (vscode) {
-			vscode.postMessage({
+		try {
+			// Send message to extension to open terminal
+			const result = await sendMessage({
 				type: 'openTerminal',
-				taskId: currentTask.id,
-				taskTitle: currentTask.title
+				data: {
+					taskId: currentTask.id,
+					taskTitle: currentTask.title
+				}
 			});
-		}
 
-		// Reset loading state after a short delay
-		setTimeout(() => {
+			// Handle the response
+			if (result && !result.success) {
+				console.error('Terminal execution failed:', result.error);
+				// The extension will show VS Code error notification and webview toast
+			} else if (result && result.success) {
+				console.log('Terminal started successfully:', result.terminalName);
+			}
+		} catch (error) {
+			console.error('Failed to start task:', error);
+			// This handles network/communication errors
+		} finally {
+			// Reset loading state
 			setIsStartingTask(false);
-		}, 500);
+		}
 	};
 
 	// Effect to handle complexity on task change

apps/extension/src/components/TaskDetailsView.tsx

@@ -208,7 +208,6 @@ export const TaskDetailsView: React.FC<TaskDetailsViewProps> = ({
 					tasks={allTasks}
 					complexity={complexity}
 					isSubtask={isSubtask}
-					sendMessage={sendMessage}
 					onStatusChange={handleStatusChange}
 					onDependencyClick={handleDependencyClick}
 				/>

apps/extension/src/extension.ts

@@ -8,6 +8,7 @@ import { ConfigService } from './services/config-service';
 import { PollingService } from './services/polling-service';
 import { createPollingStrategy } from './services/polling-strategies';
 import { TaskRepository } from './services/task-repository';
+import { TerminalManager } from './services/terminal-manager';
 import { WebviewManager } from './services/webview-manager';
 import { EventEmitter } from './utils/event-emitter';
 import { ExtensionLogger } from './utils/logger';
@@ -22,6 +23,7 @@ let logger: ExtensionLogger;
 let mcpClient: MCPClientManager;
 let api: TaskMasterApi;
 let repository: TaskRepository;
+let terminalManager: TerminalManager;
 let pollingService: PollingService;
 let webviewManager: WebviewManager;
 let events: EventEmitter;
@@ -46,6 +48,9 @@ export async function activate(context: vscode.ExtensionContext) {
 		// Repository with caching (actually useful for performance)
 		repository = new TaskRepository(api, logger);
 
+		// Terminal manager for task execution
+		terminalManager = new TerminalManager(context, logger);
+
 		// Config service for TaskMaster config.json
 		configService = new ConfigService(logger);
 
@@ -56,7 +61,13 @@ export async function activate(context: vscode.ExtensionContext) {
 		pollingService = new PollingService(repository, strategy, logger);
 
 		// Webview manager (cleaner than global panel array) - create before connection
-		webviewManager = new WebviewManager(context, repository, events, logger);
+		webviewManager = new WebviewManager(
+			context,
+			repository,
+			events,
+			logger,
+			terminalManager
+		);
 		webviewManager.setConfigService(configService);
 
 		// Sidebar webview manager
@@ -210,10 +221,11 @@ function registerCommands(context: vscode.ExtensionContext) {
 	);
 }
 
-export function deactivate() {
+export async function deactivate() {
 	logger?.log('👋 TaskMaster Extension deactivating...');
 	pollingService?.stop();
 	webviewManager?.dispose();
+	await terminalManager?.dispose();
 	api?.destroy();
 	mcpClient?.disconnect();
 }

apps/extension/src/services/terminal-manager.ts

@@ -0,0 +1,156 @@
+/**
+ * Terminal Manager - Handles task execution in VS Code terminals
+ * Uses @tm/core for consistent task management with the CLI
+ */
+
+import * as vscode from 'vscode';
+import { createTaskMasterCore, type TaskMasterCore } from '@tm/core';
+import type { ExtensionLogger } from '../utils/logger';
+
+export interface TerminalExecutionOptions {
+	taskId: string;
+	taskTitle: string;
+	tag?: string;
+}
+
+export interface TerminalExecutionResult {
+	success: boolean;
+	error?: string;
+	terminalName?: string;
+}
+
+export class TerminalManager {
+	private terminals = new Map<string, vscode.Terminal>();
+	private tmCore?: TaskMasterCore;
+
+	constructor(
+		private context: vscode.ExtensionContext,
+		private logger: ExtensionLogger
+	) {}
+
+	/**
+	 * Execute a task in a new VS Code terminal with Claude
+	 * Uses @tm/core for consistent task management with the CLI
+	 */
+	async executeTask(
+		options: TerminalExecutionOptions
+	): Promise<TerminalExecutionResult> {
+		const { taskTitle, tag } = options;
+		// Ensure taskId is always a string
+		const taskId = String(options.taskId);
+
+		this.logger.log(
+			`Starting task execution for ${taskId}: ${taskTitle}${tag ? ` (tag: ${tag})` : ''}`
+		);
+		this.logger.log(`TaskId type: ${typeof taskId}, value: ${taskId}`);
+
+		try {
+			// Initialize tm-core if needed
+			await this.initializeCore();
+
+			// Use tm-core to start the task (same as CLI)
+			const startResult = await this.tmCore!.startTask(taskId, {
+				dryRun: false,
+				force: false,
+				updateStatus: true
+			});
+
+			if (!startResult.started || !startResult.executionOutput) {
+				throw new Error(
+					startResult.error || 'Failed to start task with tm-core'
+				);
+			}
+
+			// Create terminal with custom TaskMaster icon
+			const terminalName = `Task ${taskId}: ${taskTitle}`;
+			const terminal = this.createTerminal(terminalName);
+
+			// Store terminal reference for potential cleanup
+			this.terminals.set(taskId, terminal);
+
+			// Show terminal and run Claude command
+			terminal.show();
+			const command = `claude "${startResult.executionOutput}"`;
+			terminal.sendText(command);
+
+			this.logger.log(`Launched Claude for task ${taskId} using tm-core`);
+
+			return {
+				success: true,
+				terminalName
+			};
+		} catch (error) {
+			this.logger.error('Failed to execute task:', error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : 'Unknown error'
+			};
+		}
+	}
+
+	/**
+	 * Create a new terminal with TaskMaster branding
+	 */
+	private createTerminal(name: string): vscode.Terminal {
+		const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+
+		return vscode.window.createTerminal({
+			name,
+			cwd: workspaceRoot,
+			iconPath: new vscode.ThemeIcon('play') // Use a VS Code built-in icon for now
+		});
+	}
+
+	/**
+	 * Initialize TaskMaster Core (same as CLI)
+	 */
+	private async initializeCore(): Promise<void> {
+		if (!this.tmCore) {
+			const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+			if (!workspaceRoot) {
+				throw new Error('No workspace folder found');
+			}
+			this.tmCore = await createTaskMasterCore({ projectPath: workspaceRoot });
+		}
+	}
+
+	/**
+	 * Get terminal by task ID (if still active)
+	 */
+	getTerminalByTaskId(taskId: string): vscode.Terminal | undefined {
+		return this.terminals.get(taskId);
+	}
+
+	/**
+	 * Clean up terminated terminals
+	 */
+	cleanupTerminal(taskId: string): void {
+		const terminal = this.terminals.get(taskId);
+		if (terminal) {
+			this.terminals.delete(taskId);
+		}
+	}
+
+	/**
+	 * Dispose all managed terminals and clean up tm-core
+	 */
+	async dispose(): Promise<void> {
+		this.terminals.forEach((terminal) => {
+			try {
+				terminal.dispose();
+			} catch (error) {
+				this.logger.error('Failed to dispose terminal:', error);
+			}
+		});
+		this.terminals.clear();
+
+		if (this.tmCore) {
+			try {
+				await this.tmCore.close();
+				this.tmCore = undefined;
+			} catch (error) {
+				this.logger.error('Failed to close tm-core:', error);
+			}
+		}
+	}
+}

apps/extension/src/services/webview-manager.ts

@@ -8,6 +8,7 @@ import type { EventEmitter } from '../utils/event-emitter';
 import type { ExtensionLogger } from '../utils/logger';
 import type { ConfigService } from './config-service';
 import type { TaskRepository } from './task-repository';
+import type { TerminalManager } from './terminal-manager';
 
 export class WebviewManager {
 	private panels = new Set<vscode.WebviewPanel>();
@@ -19,7 +20,8 @@ export class WebviewManager {
 		private context: vscode.ExtensionContext,
 		private repository: TaskRepository,
 		private events: EventEmitter,
-		private logger: ExtensionLogger
+		private logger: ExtensionLogger,
+		private terminalManager: TerminalManager
 	) {}
 
 	setConfigService(configService: ConfigService): void {
@@ -362,27 +364,67 @@ export class WebviewManager {
 					return;
 
 				case 'openTerminal':
-					// Open VS Code terminal for task execution
+					// Delegate terminal execution to TerminalManager
+					const { taskId, taskTitle } = data.data || data; // Handle both nested and direct data
 					this.logger.log(
-						`Opening terminal for task ${data.taskId}: ${data.taskTitle}`
+						`Webview openTerminal - taskId: ${taskId} (type: ${typeof taskId}), taskTitle: ${taskTitle}`
 					);
 
-					try {
-						const terminal = vscode.window.createTerminal({
-							name: `Task ${data.taskId}: ${data.taskTitle}`,
-							cwd: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath
-						});
-						terminal.show();
+					// Get current tag to ensure we're working in the right context
+					let currentTag = 'master'; // default fallback
+					if (this.mcpClient) {
+						try {
+							const tagsResult = await this.mcpClient.callTool('list_tags', {
+								projectRoot: vscode.workspace.workspaceFolders?.[0]?.uri.fsPath,
+								showMetadata: false
+							});
 
-						this.logger.log('Terminal created and shown successfully');
-						response = { success: true };
-					} catch (error) {
-						this.logger.error('Failed to create terminal:', error);
-						response = {
-							success: false,
-							error: error instanceof Error ? error.message : 'Unknown error'
-						};
+							let parsedData;
+							if (
+								tagsResult?.content &&
+								Array.isArray(tagsResult.content) &&
+								tagsResult.content[0]?.text
+							) {
+								try {
+									parsedData = JSON.parse(tagsResult.content[0].text);
+									if (parsedData?.data?.currentTag) {
+										currentTag = parsedData.data.currentTag;
+									}
+								} catch (e) {
+									this.logger.warn(
+										'Failed to parse tags response for terminal execution'
+									);
+								}
+							}
+						} catch (error) {
+							this.logger.warn(
+								'Failed to get current tag for terminal execution:',
+								error
+							);
+						}
 					}
+
+					const result = await this.terminalManager.executeTask({
+						taskId,
+						taskTitle,
+						tag: currentTag
+					});
+
+					response = result;
+
+					// Show user feedback AFTER sending the response (like the working "TaskMaster connected!" example)
+					setImmediate(() => {
+						if (result.success) {
+							// Success: Show info message
+							vscode.window.showInformationMessage(
+								`✅ Started Claude session for Task ${taskId}: ${taskTitle}`
+							);
+						} else {
+							// Error: Show VS Code native error notification only
+							const errorMsg = `Failed to start task: ${result.error}`;
+							vscode.window.showErrorMessage(errorMsg);
+						}
+					});
 					break;
 
 				default:

apps/extension/tsconfig.json

@@ -20,7 +20,8 @@
 		"paths": {
 			"@/*": ["./src/*"],
 			"@/components/*": ["./src/components/*"],
-			"@/lib/*": ["./src/lib/*"]
+			"@/lib/*": ["./src/lib/*"],
+			"@tm/core": ["../core/src"]
 		}
 	},
 	"exclude": ["node_modules", ".vscode-test", "out", "dist"]