@clinebot/core 0.0.32 → 0.0.34

package/src/runtime/runtime-builder.ts

@@ -39,7 +39,6 @@ import type {
 	RuntimeBuilderInput,
 	BuiltRuntime as RuntimeEnvironment,
 } from "./session-runtime";
-import { TeamRuntimeRegistry } from "./team-runtime-registry";
 
 type SkillsExecutorMetadataItem = {
 	id: string;
@@ -52,6 +51,29 @@ type SkillsExecutorWithMetadata = SkillsExecutor & {
 	configuredSkills?: SkillsExecutorMetadataItem[];
 };
 
+function isToolEnabledByPolicies(
+	toolName: string,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): boolean {
+	const globalPolicy = toolPolicies?.["*"] ?? {};
+	const toolPolicy = toolPolicies?.[toolName] ?? {};
+	return (
+		{
+			...globalPolicy,
+			...toolPolicy,
+		}.enabled !== false
+	);
+}
+
+function filterToolsByPolicies(
+	tools: Tool[],
+	toolPolicies: CoreSessionConfig["toolPolicies"],
+): Tool[] {
+	return tools.filter((tool) =>
+		isToolEnabledByPolicies(tool.name, toolPolicies),
+	);
+}
+
 export function createTeamName(): string {
 	return `team-${nanoid(5)}`;
 }
@@ -63,6 +85,7 @@ function createBuiltinToolsList(
 	yolo: boolean | undefined,
 	modelId: string,
 	toolRoutingRules: ToolRoutingRule[] | undefined,
+	toolPolicies: CoreSessionConfig["toolPolicies"],
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
@@ -74,20 +97,23 @@ function createBuiltinToolsList(
 		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
 	);
 
-	return createBuiltinTools({
-		cwd,
-		...preset,
-		enableSkills: !!skillsExecutor,
-		...toolRoutingConfig,
-		executors: {
-			...(skillsExecutor
-				? {
-						skills: skillsExecutor,
-					}
-				: {}),
-			...(executorOverrides ?? {}),
-		},
-	});
+	return filterToolsByPolicies(
+		createBuiltinTools({
+			cwd,
+			...preset,
+			enableSkills: !!skillsExecutor,
+			...toolRoutingConfig,
+			executors: {
+				...(skillsExecutor
+					? {
+							skills: skillsExecutor,
+						}
+					: {}),
+				...(executorOverrides ?? {}),
+			},
+		}),
+		toolPolicies,
+	);
 }
 
 const SKILL_FILE_NAME = "SKILL.md";
@@ -96,7 +122,7 @@ function listAvailableSkillNames(
 	watcher: UserInstructionConfigWatcher,
 	allowedSkillNames?: ReadonlyArray<string>,
 ): string[] {
-	return listConfiguredSkills(watcher, allowedSkillNames)
+	return getConfiguredSkills(watcher, allowedSkillNames)
 		.filter((skill) => !skill.disabled)
 		.map((skill) => skill.name.trim())
 		.filter((name) => name.length > 0)
@@ -143,10 +169,14 @@ function isSkillAllowed(
 	);
 }
 
-function listConfiguredSkills(
+type ConfiguredSkill = SkillsExecutorMetadataItem & {
+	skill: SkillConfig;
+};
+
+function getConfiguredSkills(
 	watcher: UserInstructionConfigWatcher,
 	allowedSkillNames?: ReadonlyArray<string>,
-): SkillsExecutorMetadataItem[] {
+): ConfiguredSkill[] {
 	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const snapshot = watcher.getSnapshot("skill");
 	return [...snapshot.entries()]
@@ -157,6 +187,7 @@ function listConfiguredSkills(
 				name: skill.name.trim(),
 				description: skill.description?.trim(),
 				disabled: skill.disabled === true,
+				skill,
 			};
 		})
 		.filter((skill) => isSkillAllowed(skill.id, skill.name, allowedSkills));
@@ -254,28 +285,22 @@ function resolveSkillRecord(
 	requestedSkill: string,
 	allowedSkillNames?: ReadonlyArray<string>,
 ): { id: string; skill: SkillConfig } | { error: string } {
-	const allowedSkills = toAllowedSkillSet(allowedSkillNames);
 	const normalized = requestedSkill.trim().replace(/^\/+/, "").toLowerCase();
 	if (!normalized) {
 		return { error: "Missing skill name." };
 	}
 
-	const snapshot = watcher.getSnapshot("skill");
-	const scopedEntries = [...snapshot.entries()].filter(([id, record]) => {
-		const skill = record.item as SkillConfig;
-		return isSkillAllowed(id, skill.name, allowedSkills);
-	});
-	const scopedSnapshot = new Map(scopedEntries);
-	const exact = scopedSnapshot.get(normalized);
+	const configuredSkills = getConfiguredSkills(watcher, allowedSkillNames);
+	const exact = configuredSkills.find((entry) => entry.id === normalized);
 	if (exact) {
-		const skill = exact.item as SkillConfig;
+		const { skill } = exact;
 		if (skill.disabled === true) {
 			return {
 				error: `Skill "${skill.name}" is configured but disabled.`,
 			};
 		}
 		return {
-			id: normalized,
+			id: exact.id,
 			skill,
 		};
 	}
@@ -284,30 +309,38 @@ function resolveSkillRecord(
 		? (normalized.split(":").at(-1) ?? normalized)
 		: normalized;
 
-	const suffixMatches = [...scopedSnapshot.entries()].filter(([id]) => {
+	const suffixMatches = configuredSkills.filter(({ id }) => {
 		if (id === bareName) {
 			return true;
 		}
 		return id.endsWith(`:${bareName}`);
 	});
 
+	const enabledSuffixMatches = suffixMatches.filter(
+		({ skill }) => skill.disabled !== true,
+	);
+
+	if (enabledSuffixMatches.length === 1) {
+		const { id, skill } = enabledSuffixMatches[0];
+		return { id, skill };
+	}
+
+	if (enabledSuffixMatches.length > 1) {
+		return {
+			error: `Skill "${requestedSkill}" is ambiguous. Use one of: ${enabledSuffixMatches.map(({ id }) => id).join(", ")}`,
+		};
+	}
+
 	if (suffixMatches.length === 1) {
-		const [id, record] = suffixMatches[0];
-		const skill = record.item as SkillConfig;
-		if (skill.disabled === true) {
-			return {
-				error: `Skill "${skill.name}" is configured but disabled.`,
-			};
-		}
+		const { skill } = suffixMatches[0];
 		return {
-			id,
-			skill,
+			error: `Skill "${skill.name}" is configured but disabled.`,
 		};
 	}
 
 	if (suffixMatches.length > 1) {
 		return {
-			error: `Skill "${requestedSkill}" is ambiguous. Use one of: ${suffixMatches.map(([id]) => id).join(", ")}`,
+			error: `Skill "${requestedSkill}" is ambiguous, and all matches are disabled: ${suffixMatches.map(({ id }) => id).join(", ")}`,
 		};
 	}
 
@@ -354,7 +387,10 @@ function createSkillsExecutor(
 		}
 	};
 	Object.defineProperty(executor, "configuredSkills", {
-		get: () => listConfiguredSkills(watcher, allowedSkillNames),
+		get: () =>
+			getConfiguredSkills(watcher, allowedSkillNames).map(
+				({ skill: _skill, ...metadata }) => metadata,
+			),
 		enumerable: true,
 		configurable: false,
 	});
@@ -386,6 +422,7 @@ function normalizeConfig(
 		| "enableTools"
 		| "enableSpawnAgent"
 		| "enableAgentTeams"
+		| "disableMcpSettingsTools"
 		| "yolo"
 		| "missionLogIntervalSteps"
 		| "missionLogIntervalMs"
@@ -407,6 +444,7 @@ function normalizeConfig(
 			config.enableSpawnAgent ?? preset.enableSpawnAgent ?? true,
 		enableAgentTeams:
 			config.enableAgentTeams ?? preset.enableAgentTeams ?? true,
+		disableMcpSettingsTools: config.disableMcpSettingsTools === true,
 		yolo: config.yolo === true,
 		missionLogIntervalSteps:
 			typeof config.missionLogIntervalSteps === "number" &&
@@ -422,7 +460,15 @@ function normalizeConfig(
 }
 
 export class DefaultRuntimeBuilder implements RuntimeBuilder {
-	private readonly teamRuntimeRegistry = new TeamRuntimeRegistry();
+	private readonly teamRuntimeEntries = new Map<
+		string,
+		{
+			runtime?: AgentTeamsRuntime;
+			delegatedAgentConfigProvider: ReturnType<
+				typeof createDelegatedAgentConfigProvider
+			>;
+		}
+	>();
 
 	async build(input: RuntimeBuilderInput): Promise<RuntimeEnvironment> {
 		const {
@@ -440,6 +486,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		const normalized = normalizeConfig(config);
 		const tools: Tool[] = [];
 		const effectiveTeamName = config.teamName?.trim() || createTeamName();
+		const hasLocalSkills = hasSkillsFiles(config.cwd);
 		let teamToolsRegistered = false;
 		const watcherProvided = Boolean(sharedUserInstructionWatcher);
 		let userInstructionWatcher = sharedUserInstructionWatcher;
@@ -447,11 +494,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 		let skillsExecutor: SkillsExecutorWithMetadata | undefined;
 		let mcpShutdown: (() => Promise<void>) | undefined;
 
-		if (
-			!userInstructionWatcher &&
-			normalized.enableTools &&
-			hasSkillsFiles(config.cwd)
-		) {
+		if (!userInstructionWatcher && normalized.enableTools && hasLocalSkills) {
 			userInstructionWatcher = createUserInstructionConfigWatcher({
 				skills: { workspacePath: config.cwd },
 				rules: { workspacePath: config.cwd },
@@ -464,8 +507,8 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			normalized.enableTools &&
 			userInstructionWatcher &&
 			(watcherProvided ||
-				hasSkillsFiles(config.cwd) ||
-				listConfiguredSkills(userInstructionWatcher, config.skills).length > 0)
+				hasLocalSkills ||
+				getConfiguredSkills(userInstructionWatcher, config.skills).length > 0)
 		) {
 			skillsExecutor = createSkillsExecutor(
 				userInstructionWatcher,
@@ -483,13 +526,16 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 					normalized.yolo,
 					config.modelId,
 					config.toolRoutingRules,
+					config.toolPolicies,
 					skillsExecutor,
 					defaultToolExecutors,
 				),
 			);
-			const mcpRuntime = await loadConfiguredMcpTools(config.logger);
-			tools.push(...mcpRuntime.tools);
-			mcpShutdown = mcpRuntime.shutdown;
+			if (!normalized.disableMcpSettingsTools) {
+				const mcpRuntime = await loadConfiguredMcpTools(config.logger);
+				tools.push(...mcpRuntime.tools);
+				mcpShutdown = mcpRuntime.shutdown;
+			}
 		}
 
 		let teamRuntime: AgentTeamsRuntime | undefined;
@@ -526,21 +572,21 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			telemetry: input.telemetry ?? config.telemetry,
 			workspaceMetadata: config.workspaceMetadata,
 		});
-		this.teamRuntimeRegistry.getOrCreate(registryKey, () => ({
-			delegatedAgentConfigProvider,
-		}));
+		if (!this.teamRuntimeEntries.has(registryKey)) {
+			this.teamRuntimeEntries.set(registryKey, {
+				delegatedAgentConfigProvider,
+			});
+		}
 
 		const ensureTeamRuntime = (): AgentTeamsRuntime | undefined => {
 			if (!normalized.enableAgentTeams) {
 				return undefined;
 			}
 
-			const registryEntry = this.teamRuntimeRegistry.getOrCreate(
-				registryKey,
-				() => ({
-					delegatedAgentConfigProvider,
-				}),
-			);
+			const registryEntry = this.teamRuntimeEntries.get(registryKey) ?? {
+				delegatedAgentConfigProvider,
+			};
+			this.teamRuntimeEntries.set(registryKey, registryEntry);
 			teamRuntime = registryEntry.runtime;
 
 			if (!teamRuntime) {
@@ -592,7 +638,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 				const factory = input.teamToolsFactory ?? bootstrapAgentTeams;
 				const teamBootstrap = factory({
 					runtime: teamRuntime,
-					leadAgentId: "lead",
+					leadAgentId: config.sessionId || "lead",
 					restoredFromPersistence: Boolean(restoredTeamState),
 					restoredTeammates: restoredTeammateSpecs,
 					includeLeadSpawnTool: true,
@@ -610,6 +656,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 									normalized.yolo,
 									config.modelId,
 									config.toolRoutingRules,
+									config.toolPolicies,
 									skillsExecutor,
 									defaultToolExecutors,
 								)
@@ -643,7 +690,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 
 		const completionGuard = normalized.enableAgentTeams
 			? () => {
-					const rt = this.teamRuntimeRegistry.get(registryKey)?.runtime;
+					const rt = this.teamRuntimeEntries.get(registryKey)?.runtime;
 					if (!rt) return undefined;
 					const tasks = rt.listTasks();
 					const hasInProgress = tasks.some(
@@ -675,13 +722,13 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			: undefined;
 
 		return {
-			tools,
+			tools: filterToolsByPolicies(tools, config.toolPolicies),
 			logger: logger ?? config.logger,
 			telemetry: telemetry ?? config.telemetry,
 			teamRuntime,
 			teamRestoredFromPersistence: Boolean(restoredTeamState),
 			delegatedAgentConfigProvider:
-				this.teamRuntimeRegistry.get(registryKey)
+				this.teamRuntimeEntries.get(registryKey)
 					?.delegatedAgentConfigProvider ?? delegatedAgentConfigProvider,
 			completionGuard,
 			registerLeadAgent: (agent) => {
@@ -692,7 +739,7 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			},
 			shutdown: async (reason: string) => {
 				shutdownTeamRuntime(teamRuntime, reason);
-				this.teamRuntimeRegistry.delete(registryKey);
+				this.teamRuntimeEntries.delete(registryKey);
 				await mcpShutdown?.();
 				if (!watcherProvided) {
 					userInstructionWatcher?.stop();

package/src/runtime/subprocess-sandbox.ts

@@ -61,6 +61,22 @@ export class SubprocessSandbox {
 		this.options = options;
 	}
 
+	private get processLabel(): string {
+		return this.options.name ?? "sandbox";
+	}
+
+	private clearPendingRequest(id: string): PendingRequest | undefined {
+		const pending = this.pending.get(id);
+		if (!pending) {
+			return undefined;
+		}
+		this.pending.delete(id);
+		if (pending.timeout) {
+			clearTimeout(pending.timeout);
+		}
+		return pending;
+	}
+
 	start(): void {
 		if (this.process && this.process.exitCode === null) {
 			return;
@@ -96,7 +112,7 @@ export class SubprocessSandbox {
 		child.on("error", (error) => {
 			this.failPending(
 				new Error(
-					`${this.options.name ?? "sandbox"} process error: ${asError(error).message}`,
+					`${this.processLabel} process error: ${asError(error).message}`,
 				),
 			);
 		});
@@ -119,9 +135,7 @@ export class SubprocessSandbox {
 		this.start();
 		const child = this.process;
 		if (!child || child.exitCode !== null) {
-			throw new Error(
-				`${this.options.name ?? "sandbox"} process is not available`,
-			);
+			throw new Error(`${this.processLabel} process is not available`);
 		}
 
 		const id = `req_${++this.requestCounter}`;
@@ -139,13 +153,13 @@ export class SubprocessSandbox {
 			};
 			if ((options.timeoutMs ?? 0) > 0) {
 				pending.timeout = setTimeout(() => {
-					this.pending.delete(id);
+					this.clearPendingRequest(id);
 					this.shutdown().catch(() => {
 						// Best-effort process shutdown after timeout.
 					});
 					reject(
 						new Error(
-							`${this.options.name ?? "sandbox"} call timed out after ${options.timeoutMs}ms: ${method}`,
+							`${this.processLabel} call timed out after ${options.timeoutMs}ms: ${method}`,
 						),
 					);
 				}, options.timeoutMs);
@@ -155,17 +169,13 @@ export class SubprocessSandbox {
 				if (!error) {
 					return;
 				}
-				const entry = this.pending.get(id);
+				const entry = this.clearPendingRequest(id);
 				if (!entry) {
 					return;
 				}
-				this.pending.delete(id);
-				if (entry.timeout) {
-					clearTimeout(entry.timeout);
-				}
 				entry.reject(
 					new Error(
-						`${this.options.name ?? "sandbox"} failed to send call "${method}": ${asError(error).message}`,
+						`${this.processLabel} failed to send call "${method}": ${asError(error).message}`,
 					),
 				);
 			});
@@ -176,7 +186,7 @@ export class SubprocessSandbox {
 		const child = this.process;
 		this.process = null;
 		if (!child || child.exitCode !== null) {
-			this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
+			this.failPending(new Error(`${this.processLabel} shutdown`));
 			return;
 		}
 		await new Promise<void>((resolve) => {
@@ -199,7 +209,7 @@ export class SubprocessSandbox {
 				resolve();
 			}
 		});
-		this.failPending(new Error(`${this.options.name ?? "sandbox"} shutdown`));
+		this.failPending(new Error(`${this.processLabel} shutdown`));
 	}
 
 	private onMessage(
@@ -220,23 +230,16 @@ export class SubprocessSandbox {
 		if (message.type !== "response" || !message.id) {
 			return;
 		}
-		const pending = this.pending.get(message.id);
+		const pending = this.clearPendingRequest(message.id);
 		if (!pending) {
 			return;
 		}
-		this.pending.delete(message.id);
-		if (pending.timeout) {
-			clearTimeout(pending.timeout);
-		}
 		if (message.ok) {
 			pending.resolve(message.result);
 			return;
 		}
 		pending.reject(
-			new Error(
-				message.error?.message ||
-					`${this.options.name ?? "sandbox"} call failed`,
-			),
+			new Error(message.error?.message || `${this.processLabel} call failed`),
 		);
 	}
 

package/src/runtime/tool-approval.ts

@@ -18,6 +18,14 @@ function delay(ms: number): Promise<void> {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function unlinkIfPresent(path: string): Promise<void> {
+	try {
+		await unlink(path);
+	} catch {
+		// Best-effort cleanup.
+	}
+}
+
 export async function requestDesktopToolApproval(
 	request: ToolApprovalRequest,
 	options: DesktopToolApprovalOptions = {},
@@ -77,16 +85,10 @@ export async function requestDesktopToolApproval(
 				approved: parsed.approved === true,
 				reason: typeof parsed.reason === "string" ? parsed.reason : undefined,
 			};
-			try {
-				await unlink(decisionPath);
-			} catch {
-				// Best-effort cleanup.
-			}
-			try {
-				await unlink(requestPath);
-			} catch {
-				// Best-effort cleanup.
-			}
+			await Promise.all([
+				unlinkIfPresent(decisionPath),
+				unlinkIfPresent(requestPath),
+			]);
 			return result;
 		} catch {
 			// Decision not available yet.
@@ -94,11 +96,7 @@ export async function requestDesktopToolApproval(
 		await delay(pollIntervalMs);
 	}
 
-	try {
-		await unlink(requestPath);
-	} catch {
-		// Best-effort cleanup.
-	}
+	await unlinkIfPresent(requestPath);
 
 	return { approved: false, reason: "Tool approval request timed out" };
 }

package/src/session/default-session-manager.ts

@@ -1391,9 +1391,7 @@ export class DefaultSessionManager implements SessionManager {
 			});
 		} catch (error) {
 			if (error instanceof OAuthReauthRequiredError) {
-				throw new Error(
-					`OAuth session for "${error.providerId}" requires re-authentication. Run "clite auth ${error.providerId}" and retry.`,
-				);
+				throw new Error(`${error.providerId} requires re-authentication.`);
 			}
 			throw error;
 		}

package/src/session/persistence-service.test.ts

@@ -200,4 +200,42 @@ describe("UnifiedSessionPersistenceService", () => {
 		);
 		expect(row?.transcriptPath).toMatch(/\.log$/);
 	});
+
+	it("deletes the full root session directory even when artifact paths are stale", async () => {
+		const sessionsDir = mkdtempSync(join(tmpdir(), "delete-root-session-dir-"));
+		tempDirs.push(sessionsDir);
+
+		const store = new SqliteSessionStore({ sessionsDir });
+		stores.push(store);
+		const service = new CoreSessionService(store);
+		const sessionId = "root-session-delete";
+		const artifacts = await service.createRootSessionWithArtifacts({
+			sessionId,
+			source: SessionSource.CLI,
+			pid: process.pid,
+			interactive: false,
+			provider: "anthropic",
+			model: "claude-sonnet-4-6",
+			cwd: "/tmp/project",
+			workspaceRoot: "/tmp/project",
+			enableTools: true,
+			enableSpawn: false,
+			enableTeams: false,
+			prompt: "delete me",
+			startedAt: "2026-04-10T19:00:00.000Z",
+		});
+
+		store.run(`UPDATE sessions SET messages_path = NULL WHERE session_id = ?`, [
+			sessionId,
+		]);
+
+		expect(existsSync(artifacts.messagesPath)).toBe(true);
+		expect(existsSync(join(sessionsDir, sessionId))).toBe(true);
+
+		const result = await service.deleteSession(sessionId);
+
+		expect(result).toEqual({ deleted: true });
+		expect(existsSync(artifacts.messagesPath)).toBe(false);
+		expect(existsSync(join(sessionsDir, sessionId))).toBe(false);
+	});
 });

package/src/session/persistence-service.ts

@@ -4,6 +4,7 @@ import {
 	readFileSync,
 	writeFileSync,
 } from "node:fs";
+import { dirname } from "node:path";
 import type * as LlmsProviders from "@clinebot/llms";
 import type { AgentResult } from "@clinebot/shared";
 import { resolveRootSessionId } from "@clinebot/shared";
@@ -922,7 +923,21 @@ export class UnifiedSessionPersistenceService {
 		unlinkIfExists(row.hookPath);
 		unlinkIfExists(row.messagesPath);
 		unlinkIfExists(this.artifacts.sessionManifestPath(id, false));
-		this.artifacts.removeSessionDirIfEmpty(id);
+		if (row.isSubagent) {
+			this.artifacts.removeSessionDirIfEmpty(id);
+		} else {
+			const candidateDirs = new Set<string>([
+				this.artifacts.sessionArtifactsDir(id),
+			]);
+			for (const path of [row.transcriptPath, row.hookPath, row.messagesPath]) {
+				if (typeof path === "string" && path.trim().length > 0) {
+					candidateDirs.add(dirname(path));
+				}
+			}
+			for (const dir of candidateDirs) {
+				this.artifacts.removeDir(dir);
+			}
+		}
 		return { deleted: true };
 	}
 }

package/src/session/session-agent-events.ts

@@ -234,7 +234,15 @@ export function handleAgentEvent(
 
 	emit({
 		type: "agent_event",
-		payload: { sessionId, event },
+		payload: {
+			sessionId,
+			event,
+			teamAgentId: overrides?.teamAgentId,
+			teamRole:
+				overrides !== undefined
+					? (overrides.teamRole ?? (isPrimaryAgentEvent ? "lead" : undefined))
+					: undefined,
+		},
 	});
 	emit({
 		type: "chunk",

package/src/session/session-artifacts.ts

@@ -3,6 +3,7 @@ import {
 	mkdirSync,
 	readdirSync,
 	rmdirSync,
+	rmSync,
 	unlinkSync,
 } from "node:fs";
 import { dirname, join } from "node:path";
@@ -116,6 +117,21 @@ export class SessionArtifacts {
 		}
 	}
 
+	public removeSessionDir(sessionId: string): void {
+		this.removeDir(this.sessionArtifactsDir(sessionId));
+	}
+
+	public removeDir(dir: string): void {
+		if (!existsSync(dir)) {
+			return;
+		}
+		try {
+			rmSync(dir, { recursive: true, force: true });
+		} catch {
+			// Best-effort cleanup.
+		}
+	}
+
 	public subagentArtifactPaths(
 		sessionId: string,
 		subAgentId: string,