diff --git a/mcp-servers/mcp-server-vscode/out/extension.js b/mcp-servers/mcp-server-vscode/out/extension.js
index 4681ef9ae..8120003bb 100644
--- a/mcp-servers/mcp-server-vscode/out/extension.js
+++ b/mcp-servers/mcp-server-vscode/out/extension.js
@@ -10,7 +10,9 @@ import packageJson from '../package.json';
 import { codeCheckerTool } from './tools/code_checker';
 import { listDebugSessions, listDebugSessionsSchema, startDebugSession, startDebugSessionSchema, stopDebugSession, stopDebugSessionSchema, } from './tools/debug_tools';
 import { focusEditorTool } from './tools/focus_editor';
+import { closeTerminal, closeTerminalSchema, createTerminal, createTerminalSchema, getTerminalOutput, getTerminalOutputSchema, listTerminals, listTerminalsSchema, sendTerminalText, sendTerminalTextSchema, } from './tools/terminal_tools';
 import { resolvePort } from './utils/port';
+import { initTerminalOutputCapture } from './utils/terminal_output_capture';
 const extensionName = 'vscode-mcp-server';
 const extensionDisplayName = 'VSCode MCP Server';
 export const activate = async (context) => {
@@ -97,6 +99,65 @@ export const activate = async (context) => {
             })),
         };
     });
+    mcpServer.tool('create_terminal', dedent `
+            Create a new integrated terminal in the VSCode workspace.
+            Optionally set a name, working directory, and an initial command to execute.
+        `.trim(), createTerminalSchema.shape, async (params) => {
+        const result = await createTerminal(params);
+        return {
+            ...result,
+            content: result.content.map((item) => ({
+                ...item,
+                type: 'text',
+            })),
+        };
+    });
+    mcpServer.tool('list_terminals', 'List all active terminals in the workspace.', listTerminalsSchema.shape, async () => {
+        const result = listTerminals();
+        return {
+            ...result,
+            content: result.content.map((item) => ({ type: 'text', text: JSON.stringify(item.json) })),
+        };
+    });
+    mcpServer.tool('send_terminal_text', dedent `
+            Send text to an existing terminal by name.
+            Use this to execute commands or type input in a terminal that was previously created.
+        `.trim(), sendTerminalTextSchema.shape, async (params) => {
+        const result = await sendTerminalText(params);
+        return {
+            ...result,
+            content: result.content.map((item) => ({
+                ...item,
+                type: 'text',
+            })),
+        };
+    });
+    mcpServer.tool('close_terminal', 'Close an active terminal by name.', closeTerminalSchema.shape, async (params) => {
+        const result = await closeTerminal(params);
+        return {
+            ...result,
+            content: result.content.map((item) => ({
+                ...item,
+                type: 'text',
+            })),
+        };
+    });
+    mcpServer.tool('get_terminal_output', dedent `
+            Read captured command output from a terminal.
+            Output is captured per-command via shell execution events.
+            Returns clean output without ANSI escape codes.
+            Requires VS Code shell integration to be active (enabled by default).
+        `.trim(), getTerminalOutputSchema.shape, async (params) => {
+        const result = await getTerminalOutput(params);
+        return {
+            ...result,
+            content: result.content.map((item) => ({
+                ...item,
+                type: 'text',
+            })),
+        };
+    });
+    initTerminalOutputCapture(context);
     const app = express();
     const mcpConfig = vscode.workspace.getConfiguration('mcpServer');
     const port = await resolvePort(mcpConfig.get('port', 6010));
@@ -198,4 +259,4 @@ export const activate = async (context) => {
 };
 export function deactivate() {
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension.js","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';\nimport dedent from 'dedent';\nimport express, { Request, Response } from 'express';\nimport * as http from 'http';\nimport * as vscode from 'vscode';\nimport { DiagnosticSeverity } from 'vscode';\nimport { z } from 'zod';\nimport packageJson from '../package.json';\nimport { codeCheckerTool } from './tools/code_checker';\nimport {\n    listDebugSessions,\n    listDebugSessionsSchema,\n    startDebugSession,\n    startDebugSessionSchema,\n    stopDebugSession,\n    stopDebugSessionSchema,\n} from './tools/debug_tools';\nimport { focusEditorTool } from './tools/focus_editor';\nimport { resolvePort } from './utils/port';\n\nconst extensionName = 'vscode-mcp-server';\nconst extensionDisplayName = 'VSCode MCP Server';\n\nexport const activate = async (context: vscode.ExtensionContext) => {\n    // Create the output channel for logging\n    const outputChannel = vscode.window.createOutputChannel(extensionDisplayName);\n\n    // Write an initial message to ensure the channel appears in the Output dropdown\n    outputChannel.appendLine(`Activating ${extensionDisplayName}...`);\n    // Uncomment to automatically switch to the output tab and this extension channel on activation\n    // outputChannel.show();\n\n    // Initialize the MCP server instance\n    const mcpServer = new McpServer({\n        name: extensionName,\n        version: packageJson.version,\n    });\n\n    // Register the \"code_checker\" tool.\n    // This tool retrieves diagnostics from VSCode's language services,\n    // filtering out files without issues.\n    mcpServer.tool(\n        'code_checker',\n        dedent`\n            Retrieve diagnostics from VSCode's language services for the active workspace.\n            Use this tool after making changes to any code in the filesystem to ensure no new\n            errors were introduced, or when requested by the user.\n        `.trim(),\n        // Passing the raw shape object directly\n        {\n            severityLevel: z\n                .enum(['Error', 'Warning', 'Information', 'Hint'])\n                .default('Warning')\n                .describe(\"Minimum severity level for checking issues: 'Error', 'Warning', 'Information', or 'Hint'.\"),\n        },\n        async (params: { severityLevel?: 'Error' | 'Warning' | 'Information' | 'Hint' }) => {\n            const severityLevel = params.severityLevel\n                ? DiagnosticSeverity[params.severityLevel]\n                : DiagnosticSeverity.Warning;\n            const result = await codeCheckerTool(severityLevel);\n            return {\n                ...result,\n                content: result.content.map((c) => ({\n                    ...c,\n                    text: typeof c.text === 'string' ? c.text : String(c.text),\n                    type: 'text',\n                })),\n            };\n        },\n    );\n\n    // Register 'focus_editor' tool\n    mcpServer.tool(\n        'focus_editor',\n        dedent`\n        Open the specified file in the VSCode editor and navigate to a specific line and column.\n        Use this tool to bring a file into focus and position the editor's cursor where desired.\n        Note: This tool operates on the editor visual environment so that the user can see the file. It does not return the file contents in the tool call result.\n        `.trim(),\n        {\n            filePath: z.string().describe('The absolute path to the file to focus in the editor.'),\n            line: z.number().int().min(0).default(0).describe('The line number to navigate to (default: 0).'),\n            column: z.number().int().min(0).default(0).describe('The column position to navigate to (default: 0).'),\n            startLine: z.number().int().min(0).optional().describe('The starting line number for highlighting.'),\n            startColumn: z.number().int().min(0).optional().describe('The starting column number for highlighting.'),\n            endLine: z.number().int().min(0).optional().describe('The ending line number for highlighting.'),\n            endColumn: z.number().int().min(0).optional().describe('The ending column number for highlighting.'),\n        },\n        async (params: { filePath: string; line?: number; column?: number }) => {\n            const result = await focusEditorTool(params);\n            return result;\n        },\n    );\n\n    // FIXME: This doesn't return results yet\n    // // Register 'search_symbol' tool\n    // mcpServer.tool(\n    //     'search_symbol',\n    //     dedent`\n    //     Search for a symbol within the workspace.\n    //     - Tries to resolve the definition via VSCode’s \"Go to Definition\".\n    //     - If not found, searches the entire workspace for the text, similar to Ctrl+Shift+F.\n    //     `.trim(),\n    //     {\n    //         query: z.string().describe('The symbol or text to search for.'),\n    //         useDefinition: z.boolean().default(true).describe(\"Whether to use 'Go to Definition' as the first method.\"),\n    //         maxResults: z.number().default(50).describe('Maximum number of global search results to return.'),\n    //         openFile: z.boolean().default(false).describe('Whether to open the found file in the editor.'),\n    //     },\n    //     async (params: { query: string; useDefinition?: boolean; maxResults?: number; openFile?: boolean }) => {\n    //         const result = await searchSymbolTool(params);\n    //         return {\n    //             ...result,\n    //             content: [\n    //                 {\n    //                     text: JSON.stringify(result),\n    //                     type: 'text',\n    //                 },\n    //             ],\n    //         };\n    //     },\n    // );\n\n    // Register 'list_debug_sessions' tool\n    mcpServer.tool(\n        'list_debug_sessions',\n        'List all active debug sessions in the workspace.',\n        listDebugSessionsSchema.shape, // No parameters required\n        async () => {\n            const result = await listDebugSessions();\n            return {\n                ...result,\n                content: result.content.map((item) => ({ type: 'text', text: JSON.stringify(item.json) })),\n            };\n        },\n    );\n\n    // Register 'start_debug_session' tool\n    mcpServer.tool(\n        'start_debug_session',\n        'Start a new debug session with the provided configuration.',\n        startDebugSessionSchema.shape,\n        async (params) => {\n            const result = await startDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'stop_debug_session' tool\n\n    // Register 'restart_debug_session' tool\n    mcpServer.tool(\n        'restart_debug_session',\n        'Restart a debug session by stopping it and then starting it with the provided configuration.',\n        startDebugSessionSchema.shape, // using the same schema as 'start_debug_session'\n        async (params) => {\n            // Stop current session using the provided session name\n            await stopDebugSession({ sessionName: params.configuration.name });\n\n            // Then start a new debug session with the given configuration\n            const result = await startDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n    mcpServer.tool(\n        'stop_debug_session',\n        'Stop all debug sessions that match the provided session name.',\n        stopDebugSessionSchema.shape,\n        async (params) => {\n            const result = await stopDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Set up an Express app to handle SSE connections\n    const app = express();\n    const mcpConfig = vscode.workspace.getConfiguration('mcpServer');\n    const port = await resolvePort(mcpConfig.get<number>('port', 6010));\n\n    let sseTransport: SSEServerTransport | undefined;\n\n    // GET /sse endpoint: the external MCP client connects here (SSE)\n    app.get('/sse', async (_req: Request, res: Response) => {\n        outputChannel.appendLine('SSE connection initiated...');\n        sseTransport = new SSEServerTransport('/messages', res);\n        try {\n            await mcpServer.connect(sseTransport);\n            outputChannel.appendLine('MCP Server connected via SSE.');\n            outputChannel.appendLine(`SSE Transport sessionId: ${sseTransport.sessionId}`);\n        } catch (err) {\n            outputChannel.appendLine('Error connecting MCP Server via SSE: ' + err);\n        }\n    });\n\n    // POST /messages endpoint: the external MCP client sends messages here\n    app.post('/messages', express.json(), async (req: Request, res: Response) => {\n        // Log in output channel\n        outputChannel.appendLine(`POST /messages: Payload - ${JSON.stringify(req.body, null, 2)}`);\n\n        if (sseTransport) {\n            // Log the session ID of the transport to confirm its initialization\n            outputChannel.appendLine(`SSE Transport sessionId: ${sseTransport.sessionId}`);\n            try {\n                // Note: Passing req.body to handlePostMessage is critical because express.json()\n                // consumes the request stream. Without this, attempting to re-read the stream\n                // within handlePostMessage would result in a \"stream is not readable\" error.\n                await sseTransport.handlePostMessage(req, res, req.body);\n                outputChannel.appendLine('Handled POST /messages successfully.');\n            } catch (err) {\n                outputChannel.appendLine('Error handling POST /messages: ' + err);\n            }\n        } else {\n            res.status(500).send('SSE Transport not initialized.');\n            outputChannel.appendLine('POST /messages failed: SSE Transport not initialized.');\n        }\n    });\n\n    // Create and start the HTTP server\n    const server = http.createServer(app);\n    function startServer(port: number): void {\n        server.listen(port, () => {\n            outputChannel.appendLine(`MCP SSE Server running at http://127.0.0.1:${port}/sse`);\n        });\n\n        // Add disposal to shut down the HTTP server and output channel on extension deactivation\n        context.subscriptions.push({\n            dispose: () => {\n                server.close();\n                outputChannel.dispose();\n            },\n        });\n    }\n    const startOnActivate = mcpConfig.get<boolean>('startOnActivate', true);\n    if (startOnActivate) {\n        startServer(port);\n    } else {\n        outputChannel.appendLine('MCP Server startup disabled by configuration.');\n    }\n\n    // COMMAND PALETTE COMMAND: Stop the MCP Server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.stopServer', () => {\n            if (!server.listening) {\n                vscode.window.showWarningMessage('MCP Server is not running.');\n                outputChannel.appendLine('Attempted to stop the MCP Server, but it is not running.');\n                return;\n            }\n            server.close(() => {\n                outputChannel.appendLine('MCP Server stopped.');\n                vscode.window.showInformationMessage('MCP Server stopped.');\n            });\n        }),\n    );\n\n    // COMMAND PALETTE COMMAND: Start the MCP Server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.startServer', async () => {\n            if (server.listening) {\n                vscode.window.showWarningMessage('MCP Server is already running.');\n                outputChannel.appendLine('Attempted to start the MCP Server, but it is already running.');\n                return;\n            }\n            const newPort = await resolvePort(mcpConfig.get<number>('port', 6010));\n            startServer(newPort);\n            outputChannel.appendLine(`MCP Server started on port ${newPort}.`);\n            vscode.window.showInformationMessage(`MCP Server started on port ${newPort}.`);\n        }),\n    );\n\n    // COMMAND PALETTE COMMAND: Set the MCP server port and restart the server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.setPort', async () => {\n            const newPortInput = await vscode.window.showInputBox({\n                prompt: 'Enter new port number for the MCP Server:',\n                value: String(port),\n                validateInput: (input) => {\n                    const num = Number(input);\n                    if (isNaN(num) || num < 1 || num > 65535) {\n                        return 'Please enter a valid port number (1-65535).';\n                    }\n                    return null;\n                },\n            });\n            if (newPortInput && newPortInput.trim().length > 0) {\n                const newPort = Number(newPortInput);\n                // Update the configuration so that subsequent startups use the new port\n                await vscode.workspace\n                    .getConfiguration('mcpServer')\n                    .update('port', newPort, vscode.ConfigurationTarget.Global);\n                // Restart the server: close existing server and start a new one\n                server.close();\n                startServer(newPort);\n                outputChannel.appendLine(`MCP Server restarted on port ${newPort}`);\n                vscode.window.showInformationMessage(`MCP Server restarted on port ${newPort}`);\n            }\n        }),\n    );\n\n    outputChannel.appendLine(`${extensionDisplayName} activated.`);\n};\n\nexport function deactivate() {\n    // Clean-up is managed by the disposables added in the activate method.\n}\n"]}
\ No newline at end of file
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"extension.js","sourceRoot":"","sources":["../src/extension.ts"],"names":[],"mappings":"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","sourcesContent":["import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';\nimport { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';\nimport dedent from 'dedent';\nimport express, { Request, Response } from 'express';\nimport * as http from 'http';\nimport * as vscode from 'vscode';\nimport { DiagnosticSeverity } from 'vscode';\nimport { z } from 'zod';\nimport packageJson from '../package.json';\nimport { codeCheckerTool } from './tools/code_checker';\nimport {\n    listDebugSessions,\n    listDebugSessionsSchema,\n    startDebugSession,\n    startDebugSessionSchema,\n    stopDebugSession,\n    stopDebugSessionSchema,\n} from './tools/debug_tools';\nimport { focusEditorTool } from './tools/focus_editor';\nimport {\n    closeTerminal,\n    closeTerminalSchema,\n    createTerminal,\n    createTerminalSchema,\n    getTerminalOutput,\n    getTerminalOutputSchema,\n    listTerminals,\n    listTerminalsSchema,\n    sendTerminalText,\n    sendTerminalTextSchema,\n} from './tools/terminal_tools';\nimport { resolvePort } from './utils/port';\nimport { initTerminalOutputCapture } from './utils/terminal_output_capture';\n\nconst extensionName = 'vscode-mcp-server';\nconst extensionDisplayName = 'VSCode MCP Server';\n\nexport const activate = async (context: vscode.ExtensionContext) => {\n    // Create the output channel for logging\n    const outputChannel = vscode.window.createOutputChannel(extensionDisplayName);\n\n    // Write an initial message to ensure the channel appears in the Output dropdown\n    outputChannel.appendLine(`Activating ${extensionDisplayName}...`);\n    // Uncomment to automatically switch to the output tab and this extension channel on activation\n    // outputChannel.show();\n\n    // Initialize the MCP server instance\n    const mcpServer = new McpServer({\n        name: extensionName,\n        version: packageJson.version,\n    });\n\n    // Register the \"code_checker\" tool.\n    // This tool retrieves diagnostics from VSCode's language services,\n    // filtering out files without issues.\n    mcpServer.tool(\n        'code_checker',\n        dedent`\n            Retrieve diagnostics from VSCode's language services for the active workspace.\n            Use this tool after making changes to any code in the filesystem to ensure no new\n            errors were introduced, or when requested by the user.\n        `.trim(),\n        // Passing the raw shape object directly\n        {\n            severityLevel: z\n                .enum(['Error', 'Warning', 'Information', 'Hint'])\n                .default('Warning')\n                .describe(\"Minimum severity level for checking issues: 'Error', 'Warning', 'Information', or 'Hint'.\"),\n        },\n        async (params: { severityLevel?: 'Error' | 'Warning' | 'Information' | 'Hint' }) => {\n            const severityLevel = params.severityLevel\n                ? DiagnosticSeverity[params.severityLevel]\n                : DiagnosticSeverity.Warning;\n            const result = await codeCheckerTool(severityLevel);\n            return {\n                ...result,\n                content: result.content.map((c) => ({\n                    ...c,\n                    text: typeof c.text === 'string' ? c.text : String(c.text),\n                    type: 'text',\n                })),\n            };\n        },\n    );\n\n    // Register 'focus_editor' tool\n    mcpServer.tool(\n        'focus_editor',\n        dedent`\n        Open the specified file in the VSCode editor and navigate to a specific line and column.\n        Use this tool to bring a file into focus and position the editor's cursor where desired.\n        Note: This tool operates on the editor visual environment so that the user can see the file. It does not return the file contents in the tool call result.\n        `.trim(),\n        {\n            filePath: z.string().describe('The absolute path to the file to focus in the editor.'),\n            line: z.number().int().min(0).default(0).describe('The line number to navigate to (default: 0).'),\n            column: z.number().int().min(0).default(0).describe('The column position to navigate to (default: 0).'),\n            startLine: z.number().int().min(0).optional().describe('The starting line number for highlighting.'),\n            startColumn: z.number().int().min(0).optional().describe('The starting column number for highlighting.'),\n            endLine: z.number().int().min(0).optional().describe('The ending line number for highlighting.'),\n            endColumn: z.number().int().min(0).optional().describe('The ending column number for highlighting.'),\n        },\n        async (params: { filePath: string; line?: number; column?: number }) => {\n            const result = await focusEditorTool(params);\n            return result;\n        },\n    );\n\n    // FIXME: This doesn't return results yet\n    // // Register 'search_symbol' tool\n    // mcpServer.tool(\n    //     'search_symbol',\n    //     dedent`\n    //     Search for a symbol within the workspace.\n    //     - Tries to resolve the definition via VSCode’s \"Go to Definition\".\n    //     - If not found, searches the entire workspace for the text, similar to Ctrl+Shift+F.\n    //     `.trim(),\n    //     {\n    //         query: z.string().describe('The symbol or text to search for.'),\n    //         useDefinition: z.boolean().default(true).describe(\"Whether to use 'Go to Definition' as the first method.\"),\n    //         maxResults: z.number().default(50).describe('Maximum number of global search results to return.'),\n    //         openFile: z.boolean().default(false).describe('Whether to open the found file in the editor.'),\n    //     },\n    //     async (params: { query: string; useDefinition?: boolean; maxResults?: number; openFile?: boolean }) => {\n    //         const result = await searchSymbolTool(params);\n    //         return {\n    //             ...result,\n    //             content: [\n    //                 {\n    //                     text: JSON.stringify(result),\n    //                     type: 'text',\n    //                 },\n    //             ],\n    //         };\n    //     },\n    // );\n\n    // Register 'list_debug_sessions' tool\n    mcpServer.tool(\n        'list_debug_sessions',\n        'List all active debug sessions in the workspace.',\n        listDebugSessionsSchema.shape, // No parameters required\n        async () => {\n            const result = await listDebugSessions();\n            return {\n                ...result,\n                content: result.content.map((item) => ({ type: 'text', text: JSON.stringify(item.json) })),\n            };\n        },\n    );\n\n    // Register 'start_debug_session' tool\n    mcpServer.tool(\n        'start_debug_session',\n        'Start a new debug session with the provided configuration.',\n        startDebugSessionSchema.shape,\n        async (params) => {\n            const result = await startDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'stop_debug_session' tool\n\n    // Register 'restart_debug_session' tool\n    mcpServer.tool(\n        'restart_debug_session',\n        'Restart a debug session by stopping it and then starting it with the provided configuration.',\n        startDebugSessionSchema.shape, // using the same schema as 'start_debug_session'\n        async (params) => {\n            // Stop current session using the provided session name\n            await stopDebugSession({ sessionName: params.configuration.name });\n\n            // Then start a new debug session with the given configuration\n            const result = await startDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n    mcpServer.tool(\n        'stop_debug_session',\n        'Stop all debug sessions that match the provided session name.',\n        stopDebugSessionSchema.shape,\n        async (params) => {\n            const result = await stopDebugSession(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'create_terminal' tool\n    mcpServer.tool(\n        'create_terminal',\n        dedent`\n            Create a new integrated terminal in the VSCode workspace.\n            Optionally set a name, working directory, and an initial command to execute.\n        `.trim(),\n        createTerminalSchema.shape,\n        async (params) => {\n            const result = await createTerminal(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'list_terminals' tool\n    mcpServer.tool(\n        'list_terminals',\n        'List all active terminals in the workspace.',\n        listTerminalsSchema.shape,\n        async () => {\n            const result = listTerminals();\n            return {\n                ...result,\n                content: result.content.map((item) => ({ type: 'text', text: JSON.stringify(item.json) })),\n            };\n        },\n    );\n\n    // Register 'send_terminal_text' tool\n    mcpServer.tool(\n        'send_terminal_text',\n        dedent`\n            Send text to an existing terminal by name.\n            Use this to execute commands or type input in a terminal that was previously created.\n        `.trim(),\n        sendTerminalTextSchema.shape,\n        async (params) => {\n            const result = await sendTerminalText(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'close_terminal' tool\n    mcpServer.tool(\n        'close_terminal',\n        'Close an active terminal by name.',\n        closeTerminalSchema.shape,\n        async (params) => {\n            const result = await closeTerminal(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Register 'get_terminal_output' tool\n    mcpServer.tool(\n        'get_terminal_output',\n        dedent`\n            Read captured command output from a terminal.\n            Output is captured per-command via shell execution events.\n            Returns clean output without ANSI escape codes.\n            Requires VS Code shell integration to be active (enabled by default).\n        `.trim(),\n        getTerminalOutputSchema.shape,\n        async (params) => {\n            const result = await getTerminalOutput(params);\n            return {\n                ...result,\n                content: result.content.map((item) => ({\n                    ...item,\n                    type: 'text' as const,\n                })),\n            };\n        },\n    );\n\n    // Initialize terminal output capture (shell execution events)\n    initTerminalOutputCapture(context);\n\n    // Set up an Express app to handle SSE connections\n    const app = express();\n    const mcpConfig = vscode.workspace.getConfiguration('mcpServer');\n    const port = await resolvePort(mcpConfig.get<number>('port', 6010));\n\n    let sseTransport: SSEServerTransport | undefined;\n\n    // GET /sse endpoint: the external MCP client connects here (SSE)\n    app.get('/sse', async (_req: Request, res: Response) => {\n        outputChannel.appendLine('SSE connection initiated...');\n        sseTransport = new SSEServerTransport('/messages', res);\n        try {\n            await mcpServer.connect(sseTransport);\n            outputChannel.appendLine('MCP Server connected via SSE.');\n            outputChannel.appendLine(`SSE Transport sessionId: ${sseTransport.sessionId}`);\n        } catch (err) {\n            outputChannel.appendLine('Error connecting MCP Server via SSE: ' + err);\n        }\n    });\n\n    // POST /messages endpoint: the external MCP client sends messages here\n    app.post('/messages', express.json(), async (req: Request, res: Response) => {\n        // Log in output channel\n        outputChannel.appendLine(`POST /messages: Payload - ${JSON.stringify(req.body, null, 2)}`);\n\n        if (sseTransport) {\n            // Log the session ID of the transport to confirm its initialization\n            outputChannel.appendLine(`SSE Transport sessionId: ${sseTransport.sessionId}`);\n            try {\n                // Note: Passing req.body to handlePostMessage is critical because express.json()\n                // consumes the request stream. Without this, attempting to re-read the stream\n                // within handlePostMessage would result in a \"stream is not readable\" error.\n                await sseTransport.handlePostMessage(req, res, req.body);\n                outputChannel.appendLine('Handled POST /messages successfully.');\n            } catch (err) {\n                outputChannel.appendLine('Error handling POST /messages: ' + err);\n            }\n        } else {\n            res.status(500).send('SSE Transport not initialized.');\n            outputChannel.appendLine('POST /messages failed: SSE Transport not initialized.');\n        }\n    });\n\n    // Create and start the HTTP server\n    const server = http.createServer(app);\n    function startServer(port: number): void {\n        server.listen(port, () => {\n            outputChannel.appendLine(`MCP SSE Server running at http://127.0.0.1:${port}/sse`);\n        });\n\n        // Add disposal to shut down the HTTP server and output channel on extension deactivation\n        context.subscriptions.push({\n            dispose: () => {\n                server.close();\n                outputChannel.dispose();\n            },\n        });\n    }\n    const startOnActivate = mcpConfig.get<boolean>('startOnActivate', true);\n    if (startOnActivate) {\n        startServer(port);\n    } else {\n        outputChannel.appendLine('MCP Server startup disabled by configuration.');\n    }\n\n    // COMMAND PALETTE COMMAND: Stop the MCP Server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.stopServer', () => {\n            if (!server.listening) {\n                vscode.window.showWarningMessage('MCP Server is not running.');\n                outputChannel.appendLine('Attempted to stop the MCP Server, but it is not running.');\n                return;\n            }\n            server.close(() => {\n                outputChannel.appendLine('MCP Server stopped.');\n                vscode.window.showInformationMessage('MCP Server stopped.');\n            });\n        }),\n    );\n\n    // COMMAND PALETTE COMMAND: Start the MCP Server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.startServer', async () => {\n            if (server.listening) {\n                vscode.window.showWarningMessage('MCP Server is already running.');\n                outputChannel.appendLine('Attempted to start the MCP Server, but it is already running.');\n                return;\n            }\n            const newPort = await resolvePort(mcpConfig.get<number>('port', 6010));\n            startServer(newPort);\n            outputChannel.appendLine(`MCP Server started on port ${newPort}.`);\n            vscode.window.showInformationMessage(`MCP Server started on port ${newPort}.`);\n        }),\n    );\n\n    // COMMAND PALETTE COMMAND: Set the MCP server port and restart the server\n    context.subscriptions.push(\n        vscode.commands.registerCommand('mcpServer.setPort', async () => {\n            const newPortInput = await vscode.window.showInputBox({\n                prompt: 'Enter new port number for the MCP Server:',\n                value: String(port),\n                validateInput: (input) => {\n                    const num = Number(input);\n                    if (isNaN(num) || num < 1 || num > 65535) {\n                        return 'Please enter a valid port number (1-65535).';\n                    }\n                    return null;\n                },\n            });\n            if (newPortInput && newPortInput.trim().length > 0) {\n                const newPort = Number(newPortInput);\n                // Update the configuration so that subsequent startups use the new port\n                await vscode.workspace\n                    .getConfiguration('mcpServer')\n                    .update('port', newPort, vscode.ConfigurationTarget.Global);\n                // Restart the server: close existing server and start a new one\n                server.close();\n                startServer(newPort);\n                outputChannel.appendLine(`MCP Server restarted on port ${newPort}`);\n                vscode.window.showInformationMessage(`MCP Server restarted on port ${newPort}`);\n            }\n        }),\n    );\n\n    outputChannel.appendLine(`${extensionDisplayName} activated.`);\n};\n\nexport function deactivate() {\n    // Clean-up is managed by the disposables added in the activate method.\n}\n"]}
\ No newline at end of file
diff --git a/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.d.ts b/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.d.ts
new file mode 100644
index 000000000..cb0ff5c3b
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.js b/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.js
new file mode 100644
index 000000000..4410ca744
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/test/terminal_tools.test.js
@@ -0,0 +1,79 @@
+import * as assert from 'assert';
+import { closeTerminalSchema, createTerminalSchema, getTerminalOutputSchema, listTerminalsSchema, sendTerminalTextSchema, } from '../tools/terminal_tools';
+suite('Terminal Tools Schema Test Suite', () => {
+    test('createTerminalSchema accepts valid params with all fields', () => {
+        const result = createTerminalSchema.safeParse({
+            name: 'my-terminal',
+            cwd: '/tmp',
+            command: 'echo hello',
+            show: true,
+        });
+        assert.strictEqual(result.success, true);
+    });
+    test('createTerminalSchema accepts empty params (all optional)', () => {
+        const result = createTerminalSchema.safeParse({});
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.show, true);
+        }
+    });
+    test('createTerminalSchema rejects invalid show type', () => {
+        const result = createTerminalSchema.safeParse({ show: 'yes' });
+        assert.strictEqual(result.success, false);
+    });
+    test('listTerminalsSchema accepts empty params', () => {
+        const result = listTerminalsSchema.safeParse({});
+        assert.strictEqual(result.success, true);
+    });
+    test('sendTerminalTextSchema requires name and text', () => {
+        const valid = sendTerminalTextSchema.safeParse({
+            name: 'my-terminal',
+            text: 'ls -la',
+        });
+        assert.strictEqual(valid.success, true);
+        const missingName = sendTerminalTextSchema.safeParse({ text: 'ls' });
+        assert.strictEqual(missingName.success, false);
+        const missingText = sendTerminalTextSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(missingText.success, false);
+    });
+    test('sendTerminalTextSchema defaults addNewLine to true', () => {
+        const result = sendTerminalTextSchema.safeParse({
+            name: 'my-terminal',
+            text: 'ls',
+        });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.addNewLine, true);
+        }
+    });
+    test('closeTerminalSchema requires name', () => {
+        const valid = closeTerminalSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(valid.success, true);
+        const missing = closeTerminalSchema.safeParse({});
+        assert.strictEqual(missing.success, false);
+    });
+    test('getTerminalOutputSchema accepts name only (defaults applied)', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.limit, 10);
+            assert.strictEqual(result.data.commandIndex, undefined);
+        }
+    });
+    test('getTerminalOutputSchema accepts commandIndex', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', commandIndex: 3 });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.commandIndex, 3);
+        }
+    });
+    test('getTerminalOutputSchema rejects limit over 50', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', limit: 100 });
+        assert.strictEqual(result.success, false);
+    });
+    test('getTerminalOutputSchema requires name', () => {
+        const result = getTerminalOutputSchema.safeParse({});
+        assert.strictEqual(result.success, false);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal_tools.test.js","sourceRoot":"","sources":["../../src/test/terminal_tools.test.ts"],"names":[],"mappings":"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","sourcesContent":["import * as assert from 'assert';\nimport {\n    closeTerminalSchema,\n    createTerminalSchema,\n    getTerminalOutputSchema,\n    listTerminalsSchema,\n    sendTerminalTextSchema,\n} from '../tools/terminal_tools';\n\nsuite('Terminal Tools Schema Test Suite', () => {\n    test('createTerminalSchema accepts valid params with all fields', () => {\n        const result = createTerminalSchema.safeParse({\n            name: 'my-terminal',\n            cwd: '/tmp',\n            command: 'echo hello',\n            show: true,\n        });\n        assert.strictEqual(result.success, true);\n    });\n\n    test('createTerminalSchema accepts empty params (all optional)', () => {\n        const result = createTerminalSchema.safeParse({});\n        assert.strictEqual(result.success, true);\n        if (result.success) {\n            assert.strictEqual(result.data.show, true); // default value\n        }\n    });\n\n    test('createTerminalSchema rejects invalid show type', () => {\n        const result = createTerminalSchema.safeParse({ show: 'yes' });\n        assert.strictEqual(result.success, false);\n    });\n\n    test('listTerminalsSchema accepts empty params', () => {\n        const result = listTerminalsSchema.safeParse({});\n        assert.strictEqual(result.success, true);\n    });\n\n    test('sendTerminalTextSchema requires name and text', () => {\n        const valid = sendTerminalTextSchema.safeParse({\n            name: 'my-terminal',\n            text: 'ls -la',\n        });\n        assert.strictEqual(valid.success, true);\n\n        const missingName = sendTerminalTextSchema.safeParse({ text: 'ls' });\n        assert.strictEqual(missingName.success, false);\n\n        const missingText = sendTerminalTextSchema.safeParse({ name: 'my-terminal' });\n        assert.strictEqual(missingText.success, false);\n    });\n\n    test('sendTerminalTextSchema defaults addNewLine to true', () => {\n        const result = sendTerminalTextSchema.safeParse({\n            name: 'my-terminal',\n            text: 'ls',\n        });\n        assert.strictEqual(result.success, true);\n        if (result.success) {\n            assert.strictEqual(result.data.addNewLine, true);\n        }\n    });\n\n    test('closeTerminalSchema requires name', () => {\n        const valid = closeTerminalSchema.safeParse({ name: 'my-terminal' });\n        assert.strictEqual(valid.success, true);\n\n        const missing = closeTerminalSchema.safeParse({});\n        assert.strictEqual(missing.success, false);\n    });\n\n    test('getTerminalOutputSchema accepts name only (defaults applied)', () => {\n        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal' });\n        assert.strictEqual(result.success, true);\n        if (result.success) {\n            assert.strictEqual(result.data.limit, 10);\n            assert.strictEqual(result.data.commandIndex, undefined);\n        }\n    });\n\n    test('getTerminalOutputSchema accepts commandIndex', () => {\n        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', commandIndex: 3 });\n        assert.strictEqual(result.success, true);\n        if (result.success) {\n            assert.strictEqual(result.data.commandIndex, 3);\n        }\n    });\n\n    test('getTerminalOutputSchema rejects limit over 50', () => {\n        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', limit: 100 });\n        assert.strictEqual(result.success, false);\n    });\n\n    test('getTerminalOutputSchema requires name', () => {\n        const result = getTerminalOutputSchema.safeParse({});\n        assert.strictEqual(result.success, false);\n    });\n});\n"]}
\ No newline at end of file
diff --git a/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.d.ts b/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.d.ts
new file mode 100644
index 000000000..cdf5311a4
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.d.ts
@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare const createTerminalSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    show: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    show: boolean;
+    name?: string | undefined;
+    cwd?: string | undefined;
+    command?: string | undefined;
+}, {
+    name?: string | undefined;
+    cwd?: string | undefined;
+    command?: string | undefined;
+    show?: boolean | undefined;
+}>;
+export declare const createTerminal: (params: z.infer<typeof createTerminalSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const listTerminalsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const listTerminals: () => {
+    content: {
+        type: string;
+        json: {
+            terminals: {
+                index: number;
+                name: string;
+                processId: Thenable<number | undefined>;
+            }[];
+        };
+    }[];
+    isError: boolean;
+};
+export declare const sendTerminalTextSchema: z.ZodObject<{
+    name: z.ZodString;
+    text: z.ZodString;
+    addNewLine: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    name: string;
+    addNewLine: boolean;
+}, {
+    text: string;
+    name: string;
+    addNewLine?: boolean | undefined;
+}>;
+export declare const sendTerminalText: (params: z.infer<typeof sendTerminalTextSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const closeTerminalSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const getTerminalOutputSchema: z.ZodObject<{
+    name: z.ZodString;
+    commandIndex: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    limit: number;
+    commandIndex?: number | undefined;
+}, {
+    name: string;
+    commandIndex?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare const getTerminalOutput: (params: z.infer<typeof getTerminalOutputSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const closeTerminal: (params: z.infer<typeof closeTerminalSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
diff --git a/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.js b/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.js
new file mode 100644
index 000000000..02c0697f5
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/tools/terminal_tools.js
@@ -0,0 +1,127 @@
+import * as vscode from 'vscode';
+import { z } from 'zod';
+import { getCommandHistory } from '../utils/terminal_output_capture';
+export const createTerminalSchema = z.object({
+    name: z.string().optional().describe('Display name for the terminal tab.'),
+    cwd: z.string().optional().describe('Working directory for the terminal.'),
+    command: z.string().optional().describe('Command to execute immediately after terminal creation.'),
+    show: z.boolean().default(true).describe('Whether to focus the terminal after creation.'),
+});
+export const createTerminal = async (params) => {
+    const { name, cwd, command, show } = params;
+    const terminal = vscode.window.createTerminal({ name, cwd });
+    if (show) {
+        terminal.show();
+    }
+    if (command) {
+        terminal.sendText(command);
+    }
+    const terminalName = terminal.name;
+    return {
+        content: [{ type: 'text', text: `Terminal '${terminalName}' created successfully.` }],
+        isError: false,
+    };
+};
+export const listTerminalsSchema = z.object({});
+export const listTerminals = () => {
+    const terminals = vscode.window.terminals.map((terminal, index) => ({
+        index,
+        name: terminal.name,
+        processId: terminal.processId,
+    }));
+    return {
+        content: [{ type: 'json', json: { terminals } }],
+        isError: false,
+    };
+};
+export const sendTerminalTextSchema = z.object({
+    name: z.string().describe('Name of the target terminal.'),
+    text: z.string().describe('Text to send to the terminal.'),
+    addNewLine: z.boolean().default(true).describe('Whether to append a newline (simulating Enter key).'),
+});
+export const sendTerminalText = async (params) => {
+    const { name, text, addNewLine } = params;
+    const terminal = vscode.window.terminals.find((t) => t.name === name);
+    if (!terminal) {
+        return {
+            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],
+            isError: true,
+        };
+    }
+    terminal.sendText(text, addNewLine);
+    terminal.show();
+    return {
+        content: [{ type: 'text', text: `Sent text to terminal '${name}'.` }],
+        isError: false,
+    };
+};
+export const closeTerminalSchema = z.object({
+    name: z.string().describe('Name of the terminal to close.'),
+});
+export const getTerminalOutputSchema = z.object({
+    name: z.string().describe('Name of the terminal to read output from.'),
+    commandIndex: z
+        .number()
+        .int()
+        .optional()
+        .describe('Index of a specific command to read (0-based, most recent last). Omit to get all recent commands.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe('Maximum number of recent commands to return (when commandIndex is not specified).'),
+});
+export const getTerminalOutput = async (params) => {
+    const { name, commandIndex, limit } = params;
+    const history = getCommandHistory(name);
+    if (!history || history.length === 0) {
+        return {
+            content: [{ type: 'text', text: `No output captured for terminal '${name}'. Shell integration may not be active.` }],
+            isError: true,
+        };
+    }
+    if (commandIndex !== undefined) {
+        if (commandIndex < 0 || commandIndex >= history.length) {
+            return {
+                content: [{ type: 'text', text: `Command index ${commandIndex} out of range (0-${history.length - 1}).` }],
+                isError: true,
+            };
+        }
+        const record = history[commandIndex];
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ command: record.command, output: record.output, index: commandIndex }) }],
+            isError: false,
+        };
+    }
+    const recent = history.slice(-limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    commands: recent.map((r, i) => ({ index: history.length - recent.length + i, command: r.command, output: r.output })),
+                    totalCommands: history.length,
+                }),
+            },
+        ],
+        isError: false,
+    };
+};
+export const closeTerminal = async (params) => {
+    const { name } = params;
+    const terminal = vscode.window.terminals.find((t) => t.name === name);
+    if (!terminal) {
+        return {
+            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],
+            isError: true,
+        };
+    }
+    terminal.dispose();
+    return {
+        content: [{ type: 'text', text: `Closed terminal '${name}'.` }],
+        isError: false,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"terminal_tools.js","sourceRoot":"","sources":["../../src/tools/terminal_tools.ts"],"names":[],"mappings":"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","sourcesContent":["import * as vscode from 'vscode';\nimport { z } from 'zod';\nimport { getCommandHistory } from '../utils/terminal_output_capture';\n\n// Zod schema for create_terminal parameters\nexport const createTerminalSchema = z.object({\n    name: z.string().optional().describe('Display name for the terminal tab.'),\n    cwd: z.string().optional().describe('Working directory for the terminal.'),\n    command: z.string().optional().describe('Command to execute immediately after terminal creation.'),\n    show: z.boolean().default(true).describe('Whether to focus the terminal after creation.'),\n});\n\n/** Create a new terminal in the workspace. */\nexport const createTerminal = async (params: z.infer<typeof createTerminalSchema>) => {\n    const { name, cwd, command, show } = params;\n\n    const terminal = vscode.window.createTerminal({ name, cwd });\n\n    if (show) {\n        terminal.show();\n    }\n\n    if (command) {\n        terminal.sendText(command);\n    }\n\n    const terminalName = terminal.name;\n\n    return {\n        content: [{ type: 'text', text: `Terminal '${terminalName}' created successfully.` }],\n        isError: false,\n    };\n};\n\n// Zod schema for list_terminals (no parameters)\nexport const listTerminalsSchema = z.object({});\n\n/** List all active terminals in the workspace. */\nexport const listTerminals = () => {\n    const terminals = vscode.window.terminals.map((terminal: vscode.Terminal, index: number) => ({\n        index,\n        name: terminal.name,\n        processId: terminal.processId,\n    }));\n\n    return {\n        content: [{ type: 'json', json: { terminals } }],\n        isError: false,\n    };\n};\n\n// Zod schema for send_terminal_text parameters\nexport const sendTerminalTextSchema = z.object({\n    name: z.string().describe('Name of the target terminal.'),\n    text: z.string().describe('Text to send to the terminal.'),\n    addNewLine: z.boolean().default(true).describe('Whether to append a newline (simulating Enter key).'),\n});\n\n/** Send text to an existing terminal by name. */\nexport const sendTerminalText = async (params: z.infer<typeof sendTerminalTextSchema>) => {\n    const { name, text, addNewLine } = params;\n    const terminal = vscode.window.terminals.find((t: vscode.Terminal) => t.name === name);\n\n    if (!terminal) {\n        return {\n            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],\n            isError: true,\n        };\n    }\n\n    terminal.sendText(text, addNewLine);\n    terminal.show();\n\n    return {\n        content: [{ type: 'text', text: `Sent text to terminal '${name}'.` }],\n        isError: false,\n    };\n};\n\n// Zod schema for close_terminal parameters\nexport const closeTerminalSchema = z.object({\n    name: z.string().describe('Name of the terminal to close.'),\n});\n\n// Zod schema for get_terminal_output parameters\nexport const getTerminalOutputSchema = z.object({\n    name: z.string().describe('Name of the terminal to read output from.'),\n    commandIndex: z\n        .number()\n        .int()\n        .optional()\n        .describe('Index of a specific command to read (0-based, most recent last). Omit to get all recent commands.'),\n    limit: z\n        .number()\n        .int()\n        .min(1)\n        .max(50)\n        .default(10)\n        .describe('Maximum number of recent commands to return (when commandIndex is not specified).'),\n});\n\n/**\n * Read captured command output from a terminal.\n *\n * Output is captured per-command via shell execution events (stable API 1.93+).\n * Returns clean output without ANSI escape codes. Requires shell integration.\n */\nexport const getTerminalOutput = async (params: z.infer<typeof getTerminalOutputSchema>) => {\n    const { name, commandIndex, limit } = params;\n    const history = getCommandHistory(name);\n\n    if (!history || history.length === 0) {\n        return {\n            content: [{ type: 'text', text: `No output captured for terminal '${name}'. Shell integration may not be active.` }],\n            isError: true,\n        };\n    }\n\n    if (commandIndex !== undefined) {\n        if (commandIndex < 0 || commandIndex >= history.length) {\n            return {\n                content: [{ type: 'text', text: `Command index ${commandIndex} out of range (0-${history.length - 1}).` }],\n                isError: true,\n            };\n        }\n        const record = history[commandIndex];\n        return {\n            content: [{ type: 'text', text: JSON.stringify({ command: record.command, output: record.output, index: commandIndex }) }],\n            isError: false,\n        };\n    }\n\n    const recent = history.slice(-limit);\n    return {\n        content: [\n            {\n                type: 'text',\n                text: JSON.stringify({\n                    commands: recent.map((r, i) => ({ index: history.length - recent.length + i, command: r.command, output: r.output })),\n                    totalCommands: history.length,\n                }),\n            },\n        ],\n        isError: false,\n    };\n};\n\n/** Close a terminal by name. */\nexport const closeTerminal = async (params: z.infer<typeof closeTerminalSchema>) => {\n    const { name } = params;\n    const terminal = vscode.window.terminals.find((t: vscode.Terminal) => t.name === name);\n\n    if (!terminal) {\n        return {\n            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],\n            isError: true,\n        };\n    }\n\n    terminal.dispose();\n\n    return {\n        content: [{ type: 'text', text: `Closed terminal '${name}'.` }],\n        isError: false,\n    };\n};\n"]}
\ No newline at end of file
diff --git a/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.d.ts b/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.d.ts
new file mode 100644
index 000000000..26b178d42
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.d.ts
@@ -0,0 +1,8 @@
+import * as vscode from 'vscode';
+interface CommandRecord {
+    command: string;
+    output: string;
+}
+export declare const initTerminalOutputCapture: (context: vscode.ExtensionContext) => void;
+export declare const getCommandHistory: (name: string) => CommandRecord[] | undefined;
+export {};
diff --git a/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.js b/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.js
new file mode 100644
index 000000000..4aea849db
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/out/utils/terminal_output_capture.js
@@ -0,0 +1,36 @@
+import * as vscode from 'vscode';
+const commandHistory = new Map();
+const MAX_HISTORY_PER_TERMINAL = 50;
+export const initTerminalOutputCapture = (context) => {
+    const startListener = vscode.window.onDidStartTerminalShellExecution(async (event) => {
+        const terminalName = event.terminal.name;
+        const execution = event.execution;
+        const chunks = [];
+        for await (const data of execution.read()) {
+            chunks.push(data);
+        }
+        const commandLine = execution.commandLine?.value ?? '(unknown)';
+        const record = {
+            command: commandLine,
+            output: chunks.join(''),
+        };
+        if (!commandHistory.has(terminalName)) {
+            commandHistory.set(terminalName, []);
+        }
+        const history = commandHistory.get(terminalName);
+        history.push(record);
+        if (history.length > MAX_HISTORY_PER_TERMINAL) {
+            history.splice(0, history.length - MAX_HISTORY_PER_TERMINAL);
+        }
+    });
+    const closeListener = vscode.window.onDidCloseTerminal((terminal) => {
+        commandHistory.delete(terminal.name);
+    });
+    context.subscriptions.push(startListener, closeListener, {
+        dispose: () => {
+            commandHistory.clear();
+        },
+    });
+};
+export const getCommandHistory = (name) => commandHistory.get(name);
+//# sourceMappingURL=data:application/json;base64,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
\ No newline at end of file
diff --git a/mcp-servers/mcp-server-vscode/src/extension.ts b/mcp-servers/mcp-server-vscode/src/extension.ts
index 85a4eb161..fc179f494 100644
--- a/mcp-servers/mcp-server-vscode/src/extension.ts
+++ b/mcp-servers/mcp-server-vscode/src/extension.ts
@@ -17,7 +17,20 @@ import {
     stopDebugSessionSchema,
 } from './tools/debug_tools';
 import { focusEditorTool } from './tools/focus_editor';
+import {
+    closeTerminal,
+    closeTerminalSchema,
+    createTerminal,
+    createTerminalSchema,
+    getTerminalOutput,
+    getTerminalOutputSchema,
+    listTerminals,
+    listTerminalsSchema,
+    sendTerminalText,
+    sendTerminalTextSchema,
+} from './tools/terminal_tools';
 import { resolvePort } from './utils/port';
+import { initTerminalOutputCapture } from './utils/terminal_output_capture';
 
 const extensionName = 'vscode-mcp-server';
 const extensionDisplayName = 'VSCode MCP Server';
@@ -191,6 +204,102 @@ export const activate = async (context: vscode.ExtensionContext) => {
         },
     );
 
+    // Register 'create_terminal' tool
+    mcpServer.tool(
+        'create_terminal',
+        dedent`
+            Create a new integrated terminal in the VSCode workspace.
+            Optionally set a name, working directory, and an initial command to execute.
+        `.trim(),
+        createTerminalSchema.shape,
+        async (params) => {
+            const result = await createTerminal(params);
+            return {
+                ...result,
+                content: result.content.map((item) => ({
+                    ...item,
+                    type: 'text' as const,
+                })),
+            };
+        },
+    );
+
+    // Register 'list_terminals' tool
+    mcpServer.tool(
+        'list_terminals',
+        'List all active terminals in the workspace.',
+        listTerminalsSchema.shape,
+        async () => {
+            const result = listTerminals();
+            return {
+                ...result,
+                content: result.content.map((item) => ({ type: 'text', text: JSON.stringify(item.json) })),
+            };
+        },
+    );
+
+    // Register 'send_terminal_text' tool
+    mcpServer.tool(
+        'send_terminal_text',
+        dedent`
+            Send text to an existing terminal by name.
+            Use this to execute commands or type input in a terminal that was previously created.
+        `.trim(),
+        sendTerminalTextSchema.shape,
+        async (params) => {
+            const result = await sendTerminalText(params);
+            return {
+                ...result,
+                content: result.content.map((item) => ({
+                    ...item,
+                    type: 'text' as const,
+                })),
+            };
+        },
+    );
+
+    // Register 'close_terminal' tool
+    mcpServer.tool(
+        'close_terminal',
+        'Close an active terminal by name.',
+        closeTerminalSchema.shape,
+        async (params) => {
+            const result = await closeTerminal(params);
+            return {
+                ...result,
+                content: result.content.map((item) => ({
+                    ...item,
+                    type: 'text' as const,
+                })),
+            };
+        },
+    );
+
+    // Register 'get_terminal_output' tool
+    mcpServer.tool(
+        'get_terminal_output',
+        dedent`
+            Read captured command output from a terminal.
+            Output is captured per-command via shell execution events.
+            Returns clean output without ANSI escape codes.
+            Requires VS Code shell integration to be active (enabled by default).
+        `.trim(),
+        getTerminalOutputSchema.shape,
+        async (params) => {
+            const result = await getTerminalOutput(params);
+            return {
+                ...result,
+                content: result.content.map((item) => ({
+                    ...item,
+                    type: 'text' as const,
+                })),
+            };
+        },
+    );
+
+    // Initialize terminal output capture (shell execution events)
+    initTerminalOutputCapture(context);
+
     // Set up an Express app to handle SSE connections
     const app = express();
     const mcpConfig = vscode.workspace.getConfiguration('mcpServer');
diff --git a/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.d.ts b/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.d.ts
new file mode 100644
index 000000000..cb0ff5c3b
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.d.ts
@@ -0,0 +1 @@
+export {};
diff --git a/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.ts b/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.ts
new file mode 100644
index 000000000..32c32d2b5
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/test/terminal_tools.test.ts
@@ -0,0 +1,98 @@
+import * as assert from 'assert';
+import {
+    closeTerminalSchema,
+    createTerminalSchema,
+    getTerminalOutputSchema,
+    listTerminalsSchema,
+    sendTerminalTextSchema,
+} from '../tools/terminal_tools';
+
+suite('Terminal Tools Schema Test Suite', () => {
+    test('createTerminalSchema accepts valid params with all fields', () => {
+        const result = createTerminalSchema.safeParse({
+            name: 'my-terminal',
+            cwd: '/tmp',
+            command: 'echo hello',
+            show: true,
+        });
+        assert.strictEqual(result.success, true);
+    });
+
+    test('createTerminalSchema accepts empty params (all optional)', () => {
+        const result = createTerminalSchema.safeParse({});
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.show, true); // default value
+        }
+    });
+
+    test('createTerminalSchema rejects invalid show type', () => {
+        const result = createTerminalSchema.safeParse({ show: 'yes' });
+        assert.strictEqual(result.success, false);
+    });
+
+    test('listTerminalsSchema accepts empty params', () => {
+        const result = listTerminalsSchema.safeParse({});
+        assert.strictEqual(result.success, true);
+    });
+
+    test('sendTerminalTextSchema requires name and text', () => {
+        const valid = sendTerminalTextSchema.safeParse({
+            name: 'my-terminal',
+            text: 'ls -la',
+        });
+        assert.strictEqual(valid.success, true);
+
+        const missingName = sendTerminalTextSchema.safeParse({ text: 'ls' });
+        assert.strictEqual(missingName.success, false);
+
+        const missingText = sendTerminalTextSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(missingText.success, false);
+    });
+
+    test('sendTerminalTextSchema defaults addNewLine to true', () => {
+        const result = sendTerminalTextSchema.safeParse({
+            name: 'my-terminal',
+            text: 'ls',
+        });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.addNewLine, true);
+        }
+    });
+
+    test('closeTerminalSchema requires name', () => {
+        const valid = closeTerminalSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(valid.success, true);
+
+        const missing = closeTerminalSchema.safeParse({});
+        assert.strictEqual(missing.success, false);
+    });
+
+    test('getTerminalOutputSchema accepts name only (defaults applied)', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal' });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.limit, 10);
+            assert.strictEqual(result.data.commandIndex, undefined);
+        }
+    });
+
+    test('getTerminalOutputSchema accepts commandIndex', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', commandIndex: 3 });
+        assert.strictEqual(result.success, true);
+        if (result.success) {
+            assert.strictEqual(result.data.commandIndex, 3);
+        }
+    });
+
+    test('getTerminalOutputSchema rejects limit over 50', () => {
+        const result = getTerminalOutputSchema.safeParse({ name: 'my-terminal', limit: 100 });
+        assert.strictEqual(result.success, false);
+    });
+
+    test('getTerminalOutputSchema requires name', () => {
+        const result = getTerminalOutputSchema.safeParse({});
+        assert.strictEqual(result.success, false);
+    });
+});
diff --git a/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.d.ts b/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.d.ts
new file mode 100644
index 000000000..ae88f63d7
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.d.ts
@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare const createTerminalSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+    command: z.ZodOptional<z.ZodString>;
+    show: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    show: boolean;
+    name?: string | undefined;
+    cwd?: string | undefined;
+    command?: string | undefined;
+}, {
+    name?: string | undefined;
+    cwd?: string | undefined;
+    command?: string | undefined;
+    show?: boolean | undefined;
+}>;
+export declare const createTerminal: (params: z.infer<typeof createTerminalSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const listTerminalsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const listTerminals: () => {
+    content: {
+        type: string;
+        json: {
+            terminals: {
+                index: number;
+                name: string;
+                processId: Thenable<number | undefined>;
+            }[];
+        };
+    }[];
+    isError: boolean;
+};
+export declare const sendTerminalTextSchema: z.ZodObject<{
+    name: z.ZodString;
+    text: z.ZodString;
+    addNewLine: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    text: string;
+    addNewLine: boolean;
+}, {
+    name: string;
+    text: string;
+    addNewLine?: boolean | undefined;
+}>;
+export declare const sendTerminalText: (params: z.infer<typeof sendTerminalTextSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const closeTerminalSchema: z.ZodObject<{
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+}, {
+    name: string;
+}>;
+export declare const getTerminalOutputSchema: z.ZodObject<{
+    name: z.ZodString;
+    commandIndex: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    limit: number;
+    commandIndex?: number | undefined;
+}, {
+    name: string;
+    commandIndex?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare const getTerminalOutput: (params: z.infer<typeof getTerminalOutputSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
+export declare const closeTerminal: (params: z.infer<typeof closeTerminalSchema>) => Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+    isError: boolean;
+}>;
diff --git a/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.ts b/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.ts
new file mode 100644
index 000000000..355023c2a
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/tools/terminal_tools.ts
@@ -0,0 +1,166 @@
+import * as vscode from 'vscode';
+import { z } from 'zod';
+import { getCommandHistory } from '../utils/terminal_output_capture';
+
+// Zod schema for create_terminal parameters
+export const createTerminalSchema = z.object({
+    name: z.string().optional().describe('Display name for the terminal tab.'),
+    cwd: z.string().optional().describe('Working directory for the terminal.'),
+    command: z.string().optional().describe('Command to execute immediately after terminal creation.'),
+    show: z.boolean().default(true).describe('Whether to focus the terminal after creation.'),
+});
+
+/** Create a new terminal in the workspace. */
+export const createTerminal = async (params: z.infer<typeof createTerminalSchema>) => {
+    const { name, cwd, command, show } = params;
+
+    const terminal = vscode.window.createTerminal({ name, cwd });
+
+    if (show) {
+        terminal.show();
+    }
+
+    if (command) {
+        terminal.sendText(command);
+    }
+
+    const terminalName = terminal.name;
+
+    return {
+        content: [{ type: 'text', text: `Terminal '${terminalName}' created successfully.` }],
+        isError: false,
+    };
+};
+
+// Zod schema for list_terminals (no parameters)
+export const listTerminalsSchema = z.object({});
+
+/** List all active terminals in the workspace. */
+export const listTerminals = () => {
+    const terminals = vscode.window.terminals.map((terminal: vscode.Terminal, index: number) => ({
+        index,
+        name: terminal.name,
+        processId: terminal.processId,
+    }));
+
+    return {
+        content: [{ type: 'json', json: { terminals } }],
+        isError: false,
+    };
+};
+
+// Zod schema for send_terminal_text parameters
+export const sendTerminalTextSchema = z.object({
+    name: z.string().describe('Name of the target terminal.'),
+    text: z.string().describe('Text to send to the terminal.'),
+    addNewLine: z.boolean().default(true).describe('Whether to append a newline (simulating Enter key).'),
+});
+
+/** Send text to an existing terminal by name. */
+export const sendTerminalText = async (params: z.infer<typeof sendTerminalTextSchema>) => {
+    const { name, text, addNewLine } = params;
+    const terminal = vscode.window.terminals.find((t: vscode.Terminal) => t.name === name);
+
+    if (!terminal) {
+        return {
+            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],
+            isError: true,
+        };
+    }
+
+    terminal.sendText(text, addNewLine);
+    terminal.show();
+
+    return {
+        content: [{ type: 'text', text: `Sent text to terminal '${name}'.` }],
+        isError: false,
+    };
+};
+
+// Zod schema for close_terminal parameters
+export const closeTerminalSchema = z.object({
+    name: z.string().describe('Name of the terminal to close.'),
+});
+
+// Zod schema for get_terminal_output parameters
+export const getTerminalOutputSchema = z.object({
+    name: z.string().describe('Name of the terminal to read output from.'),
+    commandIndex: z
+        .number()
+        .int()
+        .optional()
+        .describe('Index of a specific command to read (0-based, most recent last). Omit to get all recent commands.'),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(50)
+        .default(10)
+        .describe('Maximum number of recent commands to return (when commandIndex is not specified).'),
+});
+
+/**
+ * Read captured command output from a terminal.
+ *
+ * Output is captured per-command via shell execution events (stable API 1.93+).
+ * Returns clean output without ANSI escape codes. Requires shell integration.
+ */
+export const getTerminalOutput = async (params: z.infer<typeof getTerminalOutputSchema>) => {
+    const { name, commandIndex, limit } = params;
+    const history = getCommandHistory(name);
+
+    if (!history || history.length === 0) {
+        return {
+            content: [{ type: 'text', text: `No output captured for terminal '${name}'. Shell integration may not be active.` }],
+            isError: true,
+        };
+    }
+
+    if (commandIndex !== undefined) {
+        if (commandIndex < 0 || commandIndex >= history.length) {
+            return {
+                content: [{ type: 'text', text: `Command index ${commandIndex} out of range (0-${history.length - 1}).` }],
+                isError: true,
+            };
+        }
+        const record = history[commandIndex];
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ command: record.command, output: record.output, index: commandIndex }) }],
+            isError: false,
+        };
+    }
+
+    const recent = history.slice(-limit);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    commands: recent.map((r, i) => ({ index: history.length - recent.length + i, command: r.command, output: r.output })),
+                    totalCommands: history.length,
+                }),
+            },
+        ],
+        isError: false,
+    };
+};
+
+/** Close a terminal by name. */
+export const closeTerminal = async (params: z.infer<typeof closeTerminalSchema>) => {
+    const { name } = params;
+    const terminal = vscode.window.terminals.find((t: vscode.Terminal) => t.name === name);
+
+    if (!terminal) {
+        return {
+            content: [{ type: 'text', text: `No terminal found with name '${name}'.` }],
+            isError: true,
+        };
+    }
+
+    terminal.dispose();
+
+    return {
+        content: [{ type: 'text', text: `Closed terminal '${name}'.` }],
+        isError: false,
+    };
+};
diff --git a/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.d.ts b/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.d.ts
new file mode 100644
index 000000000..26b178d42
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.d.ts
@@ -0,0 +1,8 @@
+import * as vscode from 'vscode';
+interface CommandRecord {
+    command: string;
+    output: string;
+}
+export declare const initTerminalOutputCapture: (context: vscode.ExtensionContext) => void;
+export declare const getCommandHistory: (name: string) => CommandRecord[] | undefined;
+export {};
diff --git a/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.ts b/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.ts
new file mode 100644
index 000000000..e1ef8df9a
--- /dev/null
+++ b/mcp-servers/mcp-server-vscode/src/utils/terminal_output_capture.ts
@@ -0,0 +1,64 @@
+import * as vscode from 'vscode';
+
+interface CommandRecord {
+    command: string;
+    output: string;
+}
+
+/** Terminal name → array of command records (most recent last) */
+const commandHistory = new Map<string, CommandRecord[]>();
+
+/** Maximum number of command records to keep per terminal */
+const MAX_HISTORY_PER_TERMINAL = 50;
+
+/**
+ * Initialize terminal output capture using shell execution events.
+ *
+ * Listens to `onDidStartTerminalShellExecution` to capture per-command
+ * output via `TerminalShellExecution.read()`. This is a stable API (1.93+)
+ * that returns clean output without ANSI escape codes.
+ *
+ * Requires VS Code shell integration to be active (enabled by default).
+ */
+export const initTerminalOutputCapture = (context: vscode.ExtensionContext) => {
+    const startListener = vscode.window.onDidStartTerminalShellExecution(async (event) => {
+        const terminalName = event.terminal.name;
+        const execution = event.execution;
+        const chunks: string[] = [];
+
+        for await (const data of execution.read()) {
+            chunks.push(data);
+        }
+
+        const commandLine = execution.commandLine?.value ?? '(unknown)';
+        const record: CommandRecord = {
+            command: commandLine,
+            output: chunks.join(''),
+        };
+
+        if (!commandHistory.has(terminalName)) {
+            commandHistory.set(terminalName, []);
+        }
+
+        const history = commandHistory.get(terminalName)!;
+        history.push(record);
+
+        // Evict oldest records if over limit
+        if (history.length > MAX_HISTORY_PER_TERMINAL) {
+            history.splice(0, history.length - MAX_HISTORY_PER_TERMINAL);
+        }
+    });
+
+    const closeListener = vscode.window.onDidCloseTerminal((terminal) => {
+        commandHistory.delete(terminal.name);
+    });
+
+    context.subscriptions.push(startListener, closeListener, {
+        dispose: () => {
+            commandHistory.clear();
+        },
+    });
+};
+
+/** Get the command history for a terminal. */
+export const getCommandHistory = (name: string): CommandRecord[] | undefined => commandHistory.get(name);