chore(vscode): remove /deep-planning slash command and docs references

/deep-planning was already deprecated product-wide (removed from the
features docs, docs.json redirects updated to point elsewhere) but
remained listed in VS Code's BASE_SLASH_COMMANDS with no backend
handler behind it — selecting it just sent the literal text
"/deep-planning" to the model as an ordinary prompt, the same class of
bug fixed for /compact in CLINE-2503.

Remove the command from BASE_SLASH_COMMANDS so it no longer appears in
the autocomplete menu, and scrub the remaining doc references:

- using-commands.mdx: drop the table row and dedicated section.
- plan-and-act.mdx: drop the dedicated "Using /deep-planning" section
  and reword the "Large tasks" guidance to describe cycling between
  Plan and Act with /newtask handoffs instead of a single command.
- docs.json: repoint the four /deep-planning-related redirects at
  live pages (using-commands, plan-and-act) instead of the now-removed
  #deep-planning anchor. Redirect sources are left unchanged so old
  bookmarks/links still resolve.

apps/vscode/esbuild.mjs

@@ -1,5 +1,6 @@
 import fs from "node:fs"
 import path from "node:path"
+import { createRequire } from "node:module"
 import { fileURLToPath } from "node:url"
 import * as esbuild from "esbuild"
 
@@ -178,6 +179,39 @@ const e2eBuildConfig = {
 	plugins: [aliasResolverPlugin, esbuildProblemMatcherPlugin],
 }
 
+/**
+ * Copies the plugin sandbox bootstrap from the built @cline/core package into
+ * the extension's dist directory. The bootstrap runs in an isolated child
+ * process spawned by SubprocessSandbox and must be a separate file — it cannot
+ * be inlined into the main bundle. resolveBootstrap() (bundled into
+ * extension.js) searches for it at dist/extensions/plugin-sandbox-bootstrap.js.
+ *
+ * The bootstrap has external runtime dependencies (jiti for TypeScript
+ * transpilation, @cline/shared) that it resolves via Node's standard module
+ * resolution from its on-disk location. Both must be direct dependencies of
+ * the extension so they are present in node_modules and resolvable from
+ * dist/extensions/. The CLI build performs the same copy in apps/cli/bun.mts.
+ */
+function copyPluginSandboxBootstrap() {
+	if (e2eBuild) return
+	const projectRequire = createRequire(import.meta.url)
+	let corePackageDir
+	try {
+		corePackageDir = path.dirname(projectRequire.resolve("@cline/core/package.json"))
+	} catch {
+		console.warn("[esbuild] @cline/core not found — skipping plugin sandbox bootstrap copy")
+		return
+	}
+	const bootstrapSrc = path.join(corePackageDir, "dist", "extensions", "plugin-sandbox-bootstrap.js")
+	if (!fs.existsSync(bootstrapSrc)) {
+		console.warn(`[esbuild] plugin-sandbox-bootstrap.js not found at ${bootstrapSrc} — build @cline/core first`)
+		return
+	}
+	const bootstrapDest = path.join(__dirname, destDir, "extensions", "plugin-sandbox-bootstrap.js")
+	fs.mkdirSync(path.dirname(bootstrapDest), { recursive: true })
+	fs.copyFileSync(bootstrapSrc, bootstrapDest)
+}
+
 async function main() {
 	const config = standalone ? standaloneConfig : e2eBuild ? e2eBuildConfig : extensionConfig
 	const extensionCtx = await esbuild.context(config)
@@ -187,6 +221,7 @@ async function main() {
 		await extensionCtx.rebuild()
 		await extensionCtx.dispose()
 	}
+	copyPluginSandboxBootstrap()
 }
 
 main().catch((e) => {

apps/vscode/package.json

@@ -467,6 +467,7 @@
 		"@cline/agents": "workspace:*",
 		"@cline/core": "workspace:*",
 		"@cline/llms": "workspace:*",
+		"@cline/sdk": "workspace:*",
 		"@cline/shared": "workspace:*",
 		"@google/genai": "^1.30.0",
 		"@grpc/grpc-js": "^1.9.15",
@@ -519,6 +520,7 @@
 		"ignore": "^7.0.3",
 		"image-size": "^2.0.2",
 		"isbinaryfile": "^5.0.2",
+		"jiti": "^2.7.0",
 		"js-yaml": "^4.1.1",
 		"jschardet": "^3.1.4",
 		"json5": "^2.2.3",

apps/vscode/proto/cline/slash.proto

@@ -13,20 +13,5 @@ service SlashService {
   // Sends button click message
   rpc reportBug(StringRequest) returns (Empty);
   rpc condense(StringRequest) returns (Empty);
-
-  // Get available slash commands for autocomplete (used by CLI)
-  rpc getAvailableSlashCommands(EmptyRequest) returns (SlashCommandsResponse);
 }
 
-// Slash command definition for autocomplete
-message SlashCommandInfo {
-  string name = 1; // Command name without slash, e.g., "newtask", "smol"
-  string description = 2; // Human-readable description
-  string section = 3; // "default", "custom", or "cli"
-  bool cli_compatible = 4; // false for VS Code-only commands
-}
-
-// Response containing all available slash commands
-message SlashCommandsResponse {
-  repeated SlashCommandInfo commands = 1;
-}

apps/vscode/src/core/controller/slash/getAvailableSlashCommands.ts

@@ -1,88 +0,0 @@
-import { EmptyRequest } from "@shared/proto/cline/common"
-import { SlashCommandInfo, SlashCommandsResponse } from "@shared/proto/cline/slash"
-import { BASE_SLASH_COMMANDS } from "@/shared/slashCommands"
-import { Controller } from ".."
-
-/**
- * Returns all available slash commands for autocomplete.
- */
-export async function getAvailableSlashCommands(controller: Controller, _request: EmptyRequest): Promise<SlashCommandsResponse> {
-	const commands: SlashCommandInfo[] = []
-
-	// Add built-in commands
-	for (const cmd of [...BASE_SLASH_COMMANDS]) {
-		commands.push(
-			SlashCommandInfo.create({
-				name: cmd.name,
-				description: cmd.description,
-				section: "default",
-				cliCompatible: cmd.cliCompatible,
-			}),
-		)
-	}
-
-	// Get workflow toggles from state
-	const localWorkflowToggles = controller.stateManager.getWorkspaceStateKey("workflowToggles") ?? {}
-	const globalWorkflowToggles = controller.stateManager.getGlobalSettingsKey("globalWorkflowToggles") ?? {}
-	const remoteWorkflowToggles = controller.stateManager.getGlobalStateKey("remoteWorkflowToggles") ?? {}
-	const remoteConfigSettings = controller.stateManager.getRemoteConfigSettings()
-	const remoteWorkflows = remoteConfigSettings?.remoteGlobalWorkflows ?? []
-
-	// Track local workflow names to avoid duplicates from global
-	const localNames = new Set<string>()
-
-	// Add local workflows (enabled only)
-	for (const [path, enabled] of Object.entries(localWorkflowToggles)) {
-		if (enabled) {
-			const fileName = fullPathToFileName(path)
-			localNames.add(fileName)
-			commands.push(
-				SlashCommandInfo.create({
-					name: fileName,
-					description: `Custom workflow: ${fileName}`,
-					section: "custom",
-					cliCompatible: true,
-				}),
-			)
-		}
-	}
-
-	// Add global workflows (enabled only, skip if local exists with same name)
-	for (const [path, enabled] of Object.entries(globalWorkflowToggles)) {
-		if (enabled) {
-			const fileName = fullPathToFileName(path)
-			if (!localNames.has(fileName)) {
-				commands.push(
-					SlashCommandInfo.create({
-						name: fileName,
-						description: `Custom workflow: ${fileName}`,
-						section: "custom",
-						cliCompatible: true,
-					}),
-				)
-			}
-		}
-	}
-
-	// Add remote workflows that are enabled
-	for (const workflow of remoteWorkflows) {
-		const enabled = workflow.alwaysEnabled || remoteWorkflowToggles[workflow.name] !== false
-		if (enabled) {
-			commands.push(
-				SlashCommandInfo.create({
-					name: workflow.name,
-					description: `Remote workflow: ${workflow.name}`,
-					section: "custom",
-					cliCompatible: true,
-				}),
-			)
-		}
-	}
-
-	return SlashCommandsResponse.create({ commands })
-}
-
-function fullPathToFileName(path: string): string {
-	// e.g. replace /path/to/workflow.md with workflow.md
-	return path.replace(/^.*[/\\]/, "")
-}

apps/vscode/src/core/controller/state/getStateToPostToWebview.ts

@@ -27,6 +27,7 @@ export async function getStateToPostToWebview(controller: {
 	backgroundCommandTaskId?: string
 	workspaceManager?: any
 	checkpointRestoreInput?: ExtensionState["checkpointRestoreInput"]
+	getPluginSlashCommands?: () => Promise<{ name: string; description?: string }[]>
 }): Promise<ExtensionState> {
 	const stateManager = controller.stateManager
 
@@ -108,6 +109,15 @@ export async function getStateToPostToWebview(controller: {
 		// Codex OAuth not available
 	}
 
+	// Plugin slash commands are fetched best-effort so autocomplete failures
+	// don't block state posting.
+	let pluginSlashCommands: { name: string; description?: string }[] = []
+	try {
+		pluginSlashCommands = (await controller.getPluginSlashCommands?.()) ?? []
+	} catch {
+		// Plugin command discovery is best-effort.
+	}
+
 	return {
 		version,
 		apiConfiguration,
@@ -155,6 +165,7 @@ export async function getStateToPostToWebview(controller: {
 		taskHistory: processedTaskHistory,
 		shouldShowAnnouncement,
 		favoritedModelIds,
+		pluginSlashCommands,
 		backgroundCommandRunning: controller.backgroundCommandRunning ?? false,
 		backgroundCommandTaskId: controller.backgroundCommandTaskId,
 		workspaceRoots: controller.workspaceManager?.getRoots?.() ?? [],

apps/vscode/src/sdk/SdkController.ts

@@ -71,6 +71,7 @@ import { SdkInteractionCoordinator } from "./sdk-interaction-coordinator"
 import { SdkMcpCoordinator } from "./sdk-mcp-coordinator"
 import { SdkMessageCoordinator, type SessionEventListener } from "./sdk-message-coordinator"
 import { SdkModeCoordinator } from "./sdk-mode-coordinator"
+import { type PluginSlashCommand, SdkPluginCommandCoordinator } from "./sdk-plugin-commands"
 import { SdkProviderChangeCoordinator } from "./sdk-provider-change-coordinator"
 import { SdkSessionConfigBuilder } from "./sdk-session-config-builder"
 import { SdkSessionEventCoordinator } from "./sdk-session-event-coordinator"
@@ -166,6 +167,7 @@ export class Controller {
 	private compaction: SdkCompactionCoordinator
 	private sessionEvents: SdkSessionEventCoordinator
 	private sessionHistory: SdkSessionHistoryLoader
+	private pluginCommands: SdkPluginCommandCoordinator
 	private readonly sdkTelemetry: VscodeSdkTelemetryHandle
 	private readonly providerFailureTelemetryTurnGate = new ProviderFailureTelemetryTurnGate()
 	private readonly providerConfigStore: ProviderConfigStore
@@ -480,6 +482,7 @@ export class Controller {
 			},
 			postStateToWebview: () => this.postStateToWebview(),
 		})
+		this.pluginCommands = new SdkPluginCommandCoordinator()
 		this.taskStart = new SdkTaskStartCoordinator({
 			stateManager: this.stateManager,
 			sessions: this.sessions,
@@ -575,6 +578,16 @@ export class Controller {
 		this.providerCatalog.invalidateProviderListings()
 	}
 
+	/**
+	 * Return plugin-registered slash commands for autocomplete. Surfaced to
+	 * the webview as `pluginSlashCommands` in ExtensionState (see
+	 * getStateToPostToWebview) so the chat input's slash-command menu can
+	 * show them.
+	 */
+	getPluginSlashCommands(): Promise<PluginSlashCommand[]> {
+		return this.pluginCommands.getSlashCommands()
+	}
+
 	private handleProviderConfigChange(event: ProviderConfigChange): void {
 		this.scheduleProviderConfigStatePost()
 
@@ -677,6 +690,7 @@ export class Controller {
 		// are disposed below — see StatePostDebouncer.dispose().
 		await this.statePostDebouncer.dispose()
 		await this.invalidateUserInstructionService()
+		await this.pluginCommands.dispose()
 		this.messages.cancelPendingSave()
 		// Clear MCP tool list change callback before disposing McpHub
 		this.mcpHub?.clearToolListChangeCallback()
@@ -737,14 +751,48 @@ export class Controller {
 	}
 
 	/**
-	 * Expand a leading `/workflow` or `/skill` slash command into its instruction
-	 * body. Mirrors the CLI's `buildUserInputMessage`. Returns the input unchanged
-	 * if it is not a known command or expansion fails.
+	 * Expand a leading slash command. First checks plugin-registered commands
+	 * (e.g. `/goal`), then falls back to workflow/skill expansion via the
+	 * user-instruction service. For plugin commands:
+	 * - If the handler returns `submitPrompt`, that becomes the prompt text.
+	 * - If the handler returns `reply`, it is emitted as a say message.
+	 * - If only `reply` is returned (no `submitPrompt`), returns empty string
+	 *   so the agent turn is suppressed (the reply was already shown).
+	 * Returns the input unchanged if it is not a known command.
 	 */
 	private async resolveSlashCommands(text: string): Promise<string> {
 		if (this.isDisposed) {
 			return text
 		}
+
+		// Check plugin commands first — they take precedence over
+		// workflow/skill expansion so plugin names cannot be shadowed.
+		try {
+			const result = await this.pluginCommands.resolveCommand(text)
+			if (result) {
+				if (result.reply) {
+					this.messages.emitSessionEvents(
+						[
+							{
+								ts: Date.now(),
+								type: "say",
+								say: "text",
+								text: result.reply,
+								partial: false,
+							},
+						],
+						{
+							type: "status",
+							payload: { sessionId: this.sessions.getActiveSession()?.sessionId ?? "", status: "running" },
+						},
+					)
+				}
+				return result.submitPrompt ?? ""
+			}
+		} catch (error) {
+			Logger.warn("[SdkController] Plugin command resolution failed, falling through:", error)
+		}
+
 		try {
 			const workspaceRoot = await this.getWorkspaceRoot()
 			const service = await this.ensureUserInstructionService(workspaceRoot)
@@ -1803,6 +1851,7 @@ export class Controller {
 				mcpHub: this.mcpHub,
 				backgroundCommandRunning: this.backgroundCommandRunning,
 				backgroundCommandTaskId: this.backgroundCommandTaskId,
+				getPluginSlashCommands: () => this.pluginCommands.getSlashCommands(),
 			})
 			const sdkTaskHistory = (await this.taskHistory.listHistory({ limit: 100, hydrate: false }))
 				.map(sessionHistoryRecordToHistoryItem)

apps/vscode/src/sdk/sdk-plugin-commands.ts

@@ -0,0 +1,156 @@
+// SdkPluginCommandCoordinator — discovers and executes plugin-registered
+// slash commands, mirroring the CLI's createWorkspaceChatCommandHost.
+//
+// Plugins register commands via `api.registerCommand({ name, handler })` in
+// their setup(). The ContributionRegistry runs setup() and collects the
+// registered commands. This coordinator:
+//   1. Lazily loads plugins via resolveAndLoadAgentPlugins (sandbox mode)
+//   2. Initializes a ContributionRegistry to run setup() and gather commands
+//   3. Exposes getSlashCommands() for autocomplete
+//   4. Exposes resolveCommand(text) to execute a /command and return its result
+
+import {
+	type AgentExtensionCommand,
+	type AgentExtensionCommandResult,
+	createContributionRegistry,
+	noopBasicLogger,
+	resolveAndLoadAgentPlugins,
+} from "@cline/core"
+import type { AgentTool, Message } from "@cline/shared"
+import { Logger } from "@shared/services/Logger"
+
+export interface PluginSlashCommand {
+	name: string
+	description?: string
+}
+
+export interface PluginCommandResult {
+	reply?: string
+	submitPrompt?: string
+}
+
+interface LoadedPlugins {
+	commands: AgentExtensionCommand[]
+	shutdown: () => Promise<void>
+}
+
+export class SdkPluginCommandCoordinator {
+	private loadedPromise: Promise<LoadedPlugins | undefined> | undefined
+
+	/**
+	 * Lazily load plugins and initialize the contribution registry. The result
+	 * is cached so subsequent calls reuse the same sandbox process. Returns
+	 * undefined if no plugins are installed or loading fails.
+	 */
+	private ensureLoaded(): Promise<LoadedPlugins | undefined> {
+		if (this.loadedPromise) {
+			return this.loadedPromise
+		}
+		this.loadedPromise = (async () => {
+			let loaded: Awaited<ReturnType<typeof resolveAndLoadAgentPlugins>>
+			try {
+				loaded = await resolveAndLoadAgentPlugins({
+					logger: noopBasicLogger,
+				})
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				Logger.warn(`[PluginCommands] Plugin loading failed; continuing without plugin commands (${message})`)
+				return undefined
+			}
+			if (!loaded.extensions.length) {
+				await loaded.shutdown?.().catch(() => {})
+				return undefined
+			}
+
+			const registry = createContributionRegistry<(typeof loaded.extensions)[number], AgentTool, Message[]>({
+				extensions: loaded.extensions,
+			})
+			try {
+				await registry.initialize()
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error)
+				Logger.warn(`[PluginCommands] Contribution registry initialization failed (${message})`)
+				await loaded.shutdown?.().catch(() => {})
+				return undefined
+			}
+
+			return {
+				commands: registry.getRegistrySnapshot().commands,
+				shutdown: async () => {
+					await loaded.shutdown?.().catch(() => {})
+				},
+			}
+		})()
+		return this.loadedPromise
+	}
+
+	/**
+	 * Return plugin-registered slash commands for autocomplete. Returns an
+	 * empty array if no plugins are installed or loading fails.
+	 */
+	async getSlashCommands(): Promise<PluginSlashCommand[]> {
+		const loaded = await this.ensureLoaded()
+		if (!loaded) {
+			return []
+		}
+		return loaded.commands
+			.filter((cmd) => typeof cmd.handler === "function")
+			.map((cmd) => ({
+				name: cmd.name,
+				description: cmd.description,
+			}))
+	}
+
+	/**
+	 * Resolve a leading /command from a plugin. Returns null if the text does
+	 * not match a plugin command. Returns { reply?, submitPrompt? } from the
+	 * command handler.
+	 */
+	async resolveCommand(text: string): Promise<PluginCommandResult | null> {
+		if (!text.startsWith("/") || text.length < 2) {
+			return null
+		}
+		const match = text.match(/^\/(\S+)/)
+		if (!match?.[1]) {
+			return null
+		}
+		const name = match[1]
+		const remainder = text.slice(name.length + 1).trim()
+
+		const loaded = await this.ensureLoaded()
+		if (!loaded) {
+			return null
+		}
+		const command = loaded.commands.find((cmd) => cmd.name === name && typeof cmd.handler === "function")
+		if (!command?.handler) {
+			return null
+		}
+
+		try {
+			const result: AgentExtensionCommandResult = await command.handler(remainder)
+			if (typeof result === "string") {
+				return { reply: result }
+			}
+			return {
+				reply: result.reply,
+				submitPrompt: result.submitPrompt,
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error)
+			Logger.warn(`[PluginCommands] Command "/${name}" failed: ${message}`)
+			return { reply: `Command /${name} failed: ${message}` }
+		}
+	}
+
+	/**
+	 * Shut down the plugin sandbox process. Called on extension disposal.
+	 */
+	async dispose(): Promise<void> {
+		const promise = this.loadedPromise
+		this.loadedPromise = undefined
+		if (promise) {
+			const loaded = await promise.catch(() => undefined)
+			await loaded?.shutdown().catch(() => {})
+		}
+	}
+}

apps/vscode/src/shared/ExtensionMessage.ts

@@ -16,6 +16,7 @@ import { OnboardingModelGroup } from "./proto/cline/state"
 import { Mode } from "./storage/types"
 import { TelemetrySetting } from "./TelemetrySetting"
 import { UserInfo } from "./UserInfo"
+import type { SlashCommand } from "./slashCommands"
 // webview will hold state
 export interface ExtensionMessage {
 	type: "grpc_response" // New type for gRPC responses
@@ -114,6 +115,8 @@ export interface ExtensionState {
 	worktreesEnabled?: ClineFeatureSetting
 	customPrompt?: string
 	favoritedModelIds: string[]
+	/** Plugin-registered slash commands surfaced for autocomplete. */
+	pluginSlashCommands?: SlashCommand[]
 	// NEW: Add workspace information
 	workspaceRoots: WorkspaceRoot[]
 	primaryRootIndex: number

apps/vscode/src/shared/slashCommands.ts

@@ -2,7 +2,6 @@ export interface SlashCommand {
 	name: string
 	description?: string
 	section?: "default" | "custom" | "mcp"
-	cliCompatible?: boolean
 }
 
 export const BASE_SLASH_COMMANDS: SlashCommand[] = [
@@ -10,31 +9,21 @@ export const BASE_SLASH_COMMANDS: SlashCommand[] = [
 		name: "newtask",
 		description: "Create a new task with context from the current task",
 		section: "default",
-		cliCompatible: true,
-	},
-	{
-		name: "deep-planning",
-		description: "Create a comprehensive implementation plan before coding",
-		section: "default",
-		cliCompatible: true,
 	},
 	{
 		name: "smol",
 		description: "Condenses your current context window",
 		section: "default",
-		cliCompatible: true,
 	},
 	{
 		name: "newrule",
 		description: "Create a new Cline rule based on your conversation",
 		section: "default",
-		cliCompatible: true,
 	},
 	{
 		name: "reportbug",
 		description: "Create a Github issue with Cline",
 		section: "default",
-		cliCompatible: true,
 	},
 ]
 

apps/vscode/src/test/plugin-sandbox-bootstrap.build.test.ts

@@ -0,0 +1,67 @@
+import { existsSync } from "node:fs"
+import { readFile } from "node:fs/promises"
+import { createRequire } from "node:module"
+import { join } from "node:path"
+import { describe, expect, it } from "bun:test"
+import { $ } from "bun"
+
+/**
+ * Integration test for CLINE-2584: the plugin sandbox bootstrap
+ * (`plugin-sandbox-bootstrap.js`) must be shipped with the VS Code extension.
+ *
+ * The bootstrap runs in an isolated child process spawned by
+ * `SubprocessSandbox` — it cannot be inlined into `extension.js` because the
+ * sandbox spawns it via `node <bootstrapFile>`. The CLI build copies this
+ * file (`apps/cli/bun.mts`); the extension build (`esbuild.mjs`) must do the
+ * same.
+ *
+ * The bootstrap also has external runtime dependencies that must be resolvable
+ * from its on-disk location via Node's standard module resolution:
+ * - jiti (TypeScript transpilation of .ts plugins)
+ * - @cline/shared, @cline/sdk (host-provided SDK packages that plugins import)
+ *
+ * This test runs the real `bun esbuild.mjs` build and checks the real
+ * `dist/` output, exercising the same build pipeline CI uses.
+ */
+
+const projectRoot = join(import.meta.dir, "..", "..")
+const distDir = join(projectRoot, "dist")
+const bootstrapPath = join(distDir, "extensions", "plugin-sandbox-bootstrap.js")
+
+describe("plugin-sandbox bootstrap build artifact (CLINE-2584)", () => {
+	it("esbuild.mjs emits plugin-sandbox-bootstrap.js into dist/", async () => {
+		const result = await $`bun esbuild.mjs`.cwd(projectRoot).quiet()
+		expect(result.exitCode).toBe(0)
+
+		expect(existsSync(join(distDir, "extension.js"))).toBe(true)
+		expect(existsSync(bootstrapPath)).toBe(true)
+	}, 60_000)
+
+	it("the bootstrap is a real executable script with IPC handling", async () => {
+		expect(existsSync(bootstrapPath)).toBe(true)
+
+		const content = await readFile(bootstrapPath, "utf8")
+		expect(content.length).toBeGreaterThan(1000)
+		expect(content).toMatch(/process\.on\(.process\.message|process\.send|type:\s*["']response["']/)
+	}, 60_000)
+
+	it("the bootstrap's runtime dependencies resolve from dist/", () => {
+		expect(existsSync(bootstrapPath)).toBe(true)
+
+		// The bootstrap is spawned as a standalone Node child process. It
+		// imports jiti (for TypeScript transpilation) and @cline/shared as
+		// external modules, and plugins import @cline/sdk. Node resolves
+		// these by walking up from the bootstrap's directory. All must be
+		// direct dependencies of the extension so they appear in
+		// node_modules and are resolvable.
+		const requireFromBootstrap = createRequire(bootstrapPath)
+		expect(() => requireFromBootstrap.resolve("jiti")).not.toThrow()
+		expect(() => requireFromBootstrap.resolve("@cline/shared")).not.toThrow()
+		// @cline/sdk is a host-provided SDK specifier that plugins import.
+		// The bootstrap's findHostPackageRoot walks up from dist/extensions/
+		// looking for node_modules/@cline/sdk/package.json.
+		expect(
+			existsSync(join(projectRoot, "node_modules", "@cline", "sdk", "package.json")),
+		).toBe(true)
+	}, 60_000)
+})

apps/vscode/src/test/slash-commands.test.ts

@@ -1,285 +0,0 @@
-import { afterEach, beforeEach, describe, it } from "mocha"
-import "should"
-import * as sinon from "sinon"
-import { Controller } from "../core/controller"
-import { getAvailableSlashCommands } from "../core/controller/slash/getAvailableSlashCommands"
-import { EmptyRequest } from "../shared/proto/cline/common"
-import { BASE_SLASH_COMMANDS } from "../shared/slashCommands"
-
-/**
- * Unit tests for getAvailableSlashCommands RPC endpoint
- * Tests the slash command discovery and filtering functionality
- */
-describe("getAvailableSlashCommands", () => {
-	let mockController: Partial<Controller>
-	let mockStateManager: {
-		getWorkspaceStateKey: sinon.SinonStub
-		getGlobalSettingsKey: sinon.SinonStub
-		getGlobalStateKey: sinon.SinonStub
-		getRemoteConfigSettings: sinon.SinonStub
-	}
-
-	beforeEach(() => {
-		mockStateManager = {
-			getWorkspaceStateKey: sinon.stub(),
-			getGlobalSettingsKey: sinon.stub(),
-			getGlobalStateKey: sinon.stub(),
-			getRemoteConfigSettings: sinon.stub(),
-		}
-
-		// Default stubs return empty/null values
-		mockStateManager.getWorkspaceStateKey.returns(null)
-		mockStateManager.getGlobalSettingsKey.returns(null)
-		mockStateManager.getGlobalStateKey.returns(null)
-		mockStateManager.getRemoteConfigSettings.returns(null)
-
-		mockController = {
-			stateManager: mockStateManager as any,
-		}
-	})
-
-	afterEach(() => {
-		sinon.restore()
-	})
-
-	describe("Base Slash Commands", () => {
-		it("should return all base slash commands", async () => {
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Should have at least all base commands
-			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
-
-			// Verify each base command is present
-			for (const baseCmd of BASE_SLASH_COMMANDS) {
-				const found = response.commands.find((cmd) => cmd.name === baseCmd.name)
-				found!.should.not.be.undefined()
-				found!.description.should.equal(baseCmd.description)
-				found!.section.should.equal("default")
-				found!.cliCompatible.should.equal(baseCmd.cliCompatible ?? false)
-			}
-		})
-
-		it("should not include the deprecated subagent slash command", async () => {
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-			const deprecatedCommand = response.commands.find((cmd) => cmd.name === "subagent")
-			;(deprecatedCommand === undefined).should.be.true()
-		})
-
-		it("should mark base commands with section 'default'", async () => {
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const baseCommandNames = BASE_SLASH_COMMANDS.map((cmd) => cmd.name)
-			for (const cmd of response.commands) {
-				if (baseCommandNames.includes(cmd.name)) {
-					cmd.section.should.equal("default")
-				}
-			}
-		})
-	})
-
-	describe("Local Workflow Toggles", () => {
-		it("should include enabled local workflows", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"/path/to/my-workflow.md": true,
-				"/path/to/another-workflow.md": true,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const myWorkflow = response.commands.find((cmd) => cmd.name === "my-workflow.md")
-			myWorkflow!.should.not.be.undefined()
-			myWorkflow!.section.should.equal("custom")
-			myWorkflow!.cliCompatible.should.equal(true)
-
-			const anotherWorkflow = response.commands.find((cmd) => cmd.name === "another-workflow.md")
-			anotherWorkflow!.should.not.be.undefined()
-		})
-
-		it("should exclude disabled local workflows", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"/path/to/enabled-workflow.md": true,
-				"/path/to/disabled-workflow.md": false,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const enabled = response.commands.find((cmd) => cmd.name === "enabled-workflow.md")
-			enabled!.should.not.be.undefined()
-
-			const disabled = response.commands.find((cmd) => cmd.name === "disabled-workflow.md")
-			;(disabled === undefined).should.be.true()
-		})
-
-		it("should extract filename from full path", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"/Users/test/project/.clinerules/workflows/deep-analysis.md": true,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "deep-analysis.md")
-			workflow!.should.not.be.undefined()
-		})
-
-		it("should handle Windows-style paths", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"C:\\Users\\test\\project\\.clinerules\\workflows\\windows-workflow.md": true,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "windows-workflow.md")
-			workflow!.should.not.be.undefined()
-		})
-	})
-
-	describe("Global Workflow Toggles", () => {
-		it("should include enabled global workflows", async () => {
-			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
-				"/global/path/global-workflow.md": true,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "global-workflow.md")
-			workflow!.should.not.be.undefined()
-			workflow!.section.should.equal("custom")
-		})
-
-		it("should exclude disabled global workflows", async () => {
-			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
-				"/global/path/disabled-global.md": false,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "disabled-global.md")
-			;(workflow === undefined).should.be.true()
-		})
-	})
-
-	describe("Workflow Deduplication", () => {
-		it("should prefer local workflows over global workflows with same name", async () => {
-			// Same filename in both local and global
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"/local/path/shared-workflow.md": true,
-			})
-			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
-				"/global/path/shared-workflow.md": true,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Should only appear once
-			const matches = response.commands.filter((cmd) => cmd.name === "shared-workflow.md")
-			matches.length.should.equal(1)
-		})
-
-		it("should include global workflow if local with same name is disabled", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({
-				"/local/path/shared-workflow.md": false, // disabled locally
-			})
-			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({
-				"/global/path/shared-workflow.md": true, // enabled globally
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Global should appear since local is disabled
-			const workflow = response.commands.find((cmd) => cmd.name === "shared-workflow.md")
-			workflow!.should.not.be.undefined()
-		})
-	})
-
-	describe("Remote Workflows", () => {
-		it("should include alwaysEnabled remote workflows", async () => {
-			mockStateManager.getRemoteConfigSettings.returns({
-				remoteGlobalWorkflows: [{ name: "always-on-workflow", alwaysEnabled: true }],
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "always-on-workflow")
-			workflow!.should.not.be.undefined()
-			workflow!.section.should.equal("custom")
-		})
-
-		it("should include remote workflows enabled by toggle", async () => {
-			mockStateManager.getRemoteConfigSettings.returns({
-				remoteGlobalWorkflows: [{ name: "toggle-workflow", alwaysEnabled: false }],
-			})
-			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({
-				"toggle-workflow": true, // not explicitly disabled
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "toggle-workflow")
-			workflow!.should.not.be.undefined()
-		})
-
-		it("should exclude remote workflows explicitly disabled by toggle", async () => {
-			mockStateManager.getRemoteConfigSettings.returns({
-				remoteGlobalWorkflows: [{ name: "disabled-remote", alwaysEnabled: false }],
-			})
-			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({
-				"disabled-remote": false,
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "disabled-remote")
-			;(workflow === undefined).should.be.true()
-		})
-
-		it("should include remote workflows by default if not explicitly disabled", async () => {
-			mockStateManager.getRemoteConfigSettings.returns({
-				remoteGlobalWorkflows: [{ name: "default-enabled", alwaysEnabled: false }],
-			})
-			// No toggle entry for this workflow
-			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			const workflow = response.commands.find((cmd) => cmd.name === "default-enabled")
-			workflow!.should.not.be.undefined()
-		})
-	})
-
-	describe("Edge Cases", () => {
-		it("should handle null/undefined state values gracefully", async () => {
-			mockStateManager.getWorkspaceStateKey.returns(null)
-			mockStateManager.getGlobalSettingsKey.returns(undefined)
-			mockStateManager.getGlobalStateKey.returns(null)
-			mockStateManager.getRemoteConfigSettings.returns(null)
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Should still return base commands
-			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
-		})
-
-		it("should handle empty workflow toggle objects", async () => {
-			mockStateManager.getWorkspaceStateKey.withArgs("workflowToggles").returns({})
-			mockStateManager.getGlobalSettingsKey.withArgs("globalWorkflowToggles").returns({})
-			mockStateManager.getGlobalStateKey.withArgs("remoteWorkflowToggles").returns({})
-			mockStateManager.getRemoteConfigSettings.returns({
-				remoteGlobalWorkflows: [],
-			})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Should only have base commands
-			response.commands.length.should.equal(BASE_SLASH_COMMANDS.length)
-		})
-
-		it("should handle remote config with no remoteGlobalWorkflows property", async () => {
-			mockStateManager.getRemoteConfigSettings.returns({})
-
-			const response = await getAvailableSlashCommands(mockController as Controller, EmptyRequest.create())
-
-			// Should not throw, just return base commands
-			response.commands.length.should.be.greaterThanOrEqual(BASE_SLASH_COMMANDS.length)
-		})
-	})
-})

apps/vscode/webview-ui/src/components/chat/ChatTextArea.tsx

@@ -224,6 +224,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			remoteConfigSettings,
 			navigateToSettingsModelPicker,
 			mcpServers,
+			pluginSlashCommands,
 		} = useExtensionState()
 		const [isTextAreaFocused, setIsTextAreaFocused] = useState(false)
 		const [isDraggingOver, setIsDraggingOver] = useState(false)
@@ -489,6 +490,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 								remoteWorkflowToggles,
 								remoteConfigSettings?.remoteGlobalWorkflows,
 								mcpServers,
+								pluginSlashCommands,
 							)
 
 							if (allCommands.length === 0) {
@@ -514,6 +516,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 							remoteWorkflowToggles,
 							remoteConfigSettings?.remoteGlobalWorkflows,
 							mcpServers,
+							pluginSlashCommands,
 						)
 						if (commands.length > 0) {
 							handleSlashCommandsSelect(commands[selectedSlashCommandsIndex])
@@ -673,6 +676,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 				slashCommandsQuery,
 				handleSlashCommandsSelect,
 				sendingDisabled,
+				pluginSlashCommands,
 			],
 		)
 
@@ -984,6 +988,8 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 					globalWorkflowToggles,
 					remoteWorkflowToggles,
 					remoteConfigSettings?.remoteGlobalWorkflows,
+					mcpServers,
+					pluginSlashCommands,
 				)
 
 				if (isValidCommand) {
@@ -997,7 +1003,14 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 			highlightLayerRef.current.innerHTML = processedText
 			highlightLayerRef.current.scrollTop = textAreaRef.current.scrollTop
 			highlightLayerRef.current.scrollLeft = textAreaRef.current.scrollLeft
-		}, [localWorkflowToggles, globalWorkflowToggles, remoteWorkflowToggles, remoteConfigSettings])
+		}, [
+			localWorkflowToggles,
+			globalWorkflowToggles,
+			remoteWorkflowToggles,
+			remoteConfigSettings,
+			mcpServers,
+			pluginSlashCommands,
+		])
 
 		useLayoutEffect(() => {
 			updateHighlights()
@@ -1400,6 +1413,7 @@ const ChatTextArea = forwardRef<HTMLTextAreaElement, ChatTextAreaProps>(
 								mcpServers={mcpServers}
 								onMouseDown={handleMenuMouseDown}
 								onSelect={handleSlashCommandsSelect}
+								pluginSlashCommands={pluginSlashCommands}
 								query={slashCommandsQuery}
 								remoteWorkflows={remoteConfigSettings?.remoteGlobalWorkflows}
 								remoteWorkflowToggles={remoteWorkflowToggles}

apps/vscode/webview-ui/src/components/chat/SlashCommandMenu.tsx

@@ -16,6 +16,7 @@ interface SlashCommandMenuProps {
 	remoteWorkflowToggles?: Record<string, boolean>
 	remoteWorkflows?: any[]
 	mcpServers?: McpServer[]
+	pluginSlashCommands?: SlashCommand[]
 }
 
 const SlashCommandMenu: React.FC<SlashCommandMenuProps> = ({
@@ -29,6 +30,7 @@ const SlashCommandMenu: React.FC<SlashCommandMenuProps> = ({
 	remoteWorkflowToggles,
 	remoteWorkflows,
 	mcpServers = [],
+	pluginSlashCommands = [],
 }) => {
 	const menuRef = useRef<HTMLDivElement>(null)
 
@@ -40,6 +42,7 @@ const SlashCommandMenu: React.FC<SlashCommandMenuProps> = ({
 		remoteWorkflowToggles,
 		remoteWorkflows,
 		mcpServers,
+		pluginSlashCommands,
 	)
 	const defaultCommands = filteredCommands.filter((cmd) => cmd.section === "default" || !cmd.section)
 	const workflowCommands = filteredCommands.filter((cmd) => cmd.section === "custom")

apps/vscode/webview-ui/src/context/ExtensionStateContext.tsx

@@ -289,6 +289,7 @@ export const ExtensionStateContextProvider: React.FC<{
 		localAgentsRulesToggles: {},
 		localWorkflowToggles: {},
 		globalWorkflowToggles: {},
+		pluginSlashCommands: [],
 		shellIntegrationTimeout: 4000,
 		terminalReuseEnabled: true,
 		vscodeTerminalExecutionMode: "vscodeTerminal",
@@ -906,6 +907,7 @@ export const ExtensionStateContextProvider: React.FC<{
 		localAgentsRulesToggles: state.localAgentsRulesToggles || {},
 		localWorkflowToggles: state.localWorkflowToggles || {},
 		globalWorkflowToggles: state.globalWorkflowToggles || {},
+		pluginSlashCommands: state.pluginSlashCommands || [],
 		remoteRulesToggles: state.remoteRulesToggles || {},
 		remoteWorkflowToggles: state.remoteWorkflowToggles || {},
 		enableCheckpointsSetting: state.enableCheckpointsSetting,

apps/vscode/webview-ui/src/utils/slash-commands.ts

@@ -181,6 +181,7 @@ export function getMatchingSlashCommands(
 	remoteWorkflowToggles?: Record<string, boolean>,
 	remoteWorkflows?: any[],
 	mcpServers: McpServer[] = [],
+	pluginSlashCommands: SlashCommand[] = [],
 ): SlashCommand[] {
 	const workflowCommands = getWorkflowCommands(
 		localWorkflowToggles,
@@ -189,7 +190,7 @@ export function getMatchingSlashCommands(
 		remoteWorkflows,
 	)
 	const mcpPromptCommands = getMcpPromptCommands(mcpServers)
-	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands]
+	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands, ...pluginSlashCommands]
 
 	if (!query) {
 		return allCommands
@@ -233,6 +234,7 @@ export function validateSlashCommand(
 	remoteWorkflowToggles?: Record<string, boolean>,
 	remoteWorkflows?: any[],
 	mcpServers: McpServer[] = [],
+	pluginSlashCommands: SlashCommand[] = [],
 ): "full" | "partial" | null {
 	if (!command) {
 		return null
@@ -245,7 +247,7 @@ export function validateSlashCommand(
 		remoteWorkflows,
 	)
 	const mcpPromptCommands = getMcpPromptCommands(mcpServers)
-	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands]
+	const allCommands = [...DEFAULT_SLASH_COMMANDS, ...workflowCommands, ...mcpPromptCommands, ...pluginSlashCommands]
 
 	// case insensitive matching
 	const exactMatch = allCommands.some((cmd) => cmd.name.toLowerCase() === command.toLowerCase())

docs/core-workflows/plan-and-act.mdx

@@ -80,17 +80,6 @@ When enabled, switching between Plan and Act mode automatically switches to the
 | Maximum quality | Claude Opus | Claude Sonnet |
 | Speed-focused | Gemini 3 Flash | Cerebras |
 
-## Using `/deep-planning`
-
-For complex tasks that need thorough analysis, use the `/deep-planning` slash command. This triggers an extended planning session where Cline:
-
-1. Explores the codebase systematically
-2. Identifies all affected files and dependencies
-3. Creates a detailed implementation plan
-4. Asks clarifying questions before proceeding
-
-The deep planning prompt is optimized for each model family, so it adapts to the strengths of whatever model you're using. See [/deep-planning](/core-workflows/using-commands#deep-planning) for more details.
-
 ## Choosing the Right Approach by Task Size
 
 ### Small tasks: Act mode only
@@ -105,9 +94,9 @@ For most development work, start in Plan mode to understand the scope and approa
 
 **Examples:** Add a new API endpoint, implement a UI component, fix a bug that requires investigation, refactor a single module.
 
-### Large tasks: Use `/deep-planning`
+### Large tasks: Plan → Act with multiple cycles
 
-For complex features that span multiple files, require architectural decisions, or will take multiple sessions to complete, use the `/deep-planning` slash command. This creates a detailed implementation plan that Cline can reference throughout the work.
+For complex features that span multiple files, require architectural decisions, or will take multiple sessions to complete, start in Plan mode to map out the full scope. Break the work into manageable chunks, and cycle between Plan and Act modes as needed. Use `/newtask` to hand off progress when your context gets full.
 
 **Examples:** Add a new feature across frontend and backend, major refactoring across the codebase, implementing a new system or integration, multi-step migrations.
 

docs/core-workflows/using-commands.mdx

@@ -19,7 +19,6 @@ Type `/` in the chat input to see available slash commands:
 | `/newtask` | Start fresh task with distilled context from current conversation |
 | `/smol` | Compress conversation history while preserving essential context |
 | `/newrule` | Create a rule file to teach Cline your preferences |
-| `/deep-planning` | Investigate codebase, plan thoroughly, then create implementation task |
 | `/reportbug` | Report a bug with diagnostic info |
 
 ### /newtask
@@ -40,17 +39,6 @@ Use `/smol` when you're deep into a debugging session or brainstorming and need
 
 Use `/newrule` when you find yourself repeating the same instructions across tasks. For more about rules, see [Cline Rules](/customization/cline-rules).
 
-### /deep-planning
-
-Transform Cline into a meticulous architect who investigates your codebase, asks clarifying questions, and creates a comprehensive implementation plan before writing any code. Deep planning follows a four-step process:
-
-1. **Silent Investigation** - Cline explores your codebase structure and patterns
-2. **Discussion** - Targeted questions about requirements and approach
-3. **Plan Creation** - Generates `implementation_plan.md` with detailed specifications
-4. **Task Creation** - Creates a new task with trackable implementation steps
-
-Use `/deep-planning` for features touching multiple parts of your codebase, architectural changes, or complex integrations.
-
 ### /reportbug
 
 `/reportbug` collects diagnostic information and helps you report issues with Cline. It gathers relevant context like your configuration, recent errors, and system details to make bug reports more useful for the development team.

docs/docs.json

@@ -458,11 +458,11 @@
 		},
 		{
 			"source": "/customization/focus-chain",
-			"destination": "/core-workflows/using-commands#deep-planning"
+			"destination": "/core-workflows/using-commands"
 		},
 		{
 			"source": "/features/deep-planning",
-			"destination": "/core-workflows/using-commands#deep-planning"
+			"destination": "/core-workflows/plan-and-act"
 		},
 		{
 			"source": "/customization/auto-approve",
@@ -650,7 +650,7 @@
 		},
 		{
 			"source": "/features/slash-commands/deep-planning",
-			"destination": "/core-workflows/using-commands#deep-planning"
+			"destination": "/core-workflows/plan-and-act"
 		},
 		{
 			"source": "/features/slash-commands/smol",
@@ -666,7 +666,7 @@
 		},
 		{
 			"source": "/features/focus-chain",
-			"destination": "/core-workflows/using-commands#deep-planning"
+			"destination": "/core-workflows/using-commands"
 		},
 		{
 			"source": "/features/skills",