@clinebot/core 0.0.33 → 0.0.34

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-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,

package/src/session/session-config-builder.ts

@@ -1,5 +1,9 @@
 import type { ITelemetryService } from "@clinebot/shared";
 import { resolveAndLoadAgentPlugins } from "../extensions/plugin/plugin-config-loader";
+import type {
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+} from "../extensions/plugin/plugin-load-report";
 import {
 	createHookAuditHooks,
 	createHookConfigFileHooks,
@@ -15,6 +19,43 @@ import {
 import type { StartSessionInput } from "./session-manager";
 import { hasRuntimeHooks, mergeAgentExtensions } from "./utils/helpers";
 
+function formatPluginFailure(failure: PluginInitializationFailure): string {
+	const label = failure.pluginName ?? failure.pluginPath;
+	return `${label}: ${failure.message}`;
+}
+
+function logPluginDiagnostics(
+	failures: PluginInitializationFailure[],
+	warnings: PluginInitializationWarning[],
+	logger: CoreSessionConfig["logger"],
+): void {
+	if (warnings.length > 0) {
+		for (const warning of warnings) {
+			logger?.log(warning.message, { severity: "warn" });
+		}
+	}
+	if (failures.length === 0) {
+		return;
+	}
+	const preview = failures.slice(0, 3).map(formatPluginFailure).join("; ");
+	const suffix = failures.length > 3 ? `; and ${failures.length - 3} more` : "";
+	logger?.log(
+		`Some plugins failed to initialize. ${preview}${suffix}. Use --verbose for more details.`,
+		{ severity: "warn" },
+	);
+	for (const failure of failures) {
+		logger?.log(
+			`Plugin initialization failed (${failure.phase}) for ${failure.pluginPath}`,
+			{
+				severity: "warn",
+				stack: failure.stack,
+				pluginPath: failure.pluginPath,
+				pluginName: failure.pluginName,
+			},
+		);
+	}
+}
+
 export function resolveWorkspacePath(config: CoreSessionConfig): string {
 	return config.workspaceRoot ?? config.cwd;
 }
@@ -61,6 +102,11 @@ export async function buildEffectiveConfig(
 			cwd: input.config.cwd,
 			onEvent: onPluginEvent,
 		});
+		logPluginDiagnostics(
+			loadedPlugins.failures,
+			loadedPlugins.warnings,
+			input.config.logger,
+		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		input.config.logger?.log?.(

package/src/team/team-tools.test.ts

@@ -743,6 +743,110 @@ describe("createAgentTeamsTools runtime behavior", () => {
 		expect(awaitAllRuns?.timeoutMs).toBe(60 * 60 * 1000);
 	});
 
+	it("deduplicates concurrent sync team_run_task calls to the same agent", async () => {
+		let resolveRoute!: (value: { text: string; iterations: number }) => void;
+		const routePromise = new Promise<{ text: string; iterations: number }>(
+			(resolve) => {
+				resolveRoute = resolve;
+			},
+		);
+		const routeToTeammate = vi.fn(() => routePromise);
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+		const input = {
+			agentId: "educator",
+			task: "Explain probability",
+			runMode: "sync",
+		};
+
+		// Fire two concurrent sync calls to the same agent
+		const call1 = runTask.execute(input, ctx);
+		const call2 = runTask.execute(input, ctx);
+
+		// Second call should throw with duplicate detection error
+		await expect(call2).rejects.toThrow(
+			'Duplicate team_run_task call detected for agent "educator"',
+		);
+
+		// Only one routeToTeammate call should have been made
+		expect(routeToTeammate).toHaveBeenCalledTimes(1);
+
+		// Now resolve the first call
+		resolveRoute({ text: "Probability explained", iterations: 3 });
+		const result1 = (await call1) as { text?: string; iterations?: number };
+		expect(result1.text).toBe("Probability explained");
+		expect(result1.iterations).toBe(3);
+	});
+
+	it("allows concurrent sync team_run_task calls to different agents", async () => {
+		let resolveRoute1!: (value: { text: string; iterations: number }) => void;
+		let resolveRoute2!: (value: { text: string; iterations: number }) => void;
+		const routeToTeammate = vi.fn((agentId: string) => {
+			if (agentId === "educator") {
+				return new Promise<{ text: string; iterations: number }>((resolve) => {
+					resolveRoute1 = resolve;
+				});
+			}
+			return new Promise<{ text: string; iterations: number }>((resolve) => {
+				resolveRoute2 = resolve;
+			});
+		});
+		const runtime = {
+			routeToTeammate,
+			getMemberRole: vi.fn(() => "lead"),
+		} as unknown as AgentTeamsRuntime;
+
+		const tools = createAgentTeamsTools({
+			runtime,
+			requesterId: "lead",
+			teammateConfigProvider: makeTeammateConfigProvider(),
+		});
+		const runTask = tools.find((tool) => tool.name === "team_run_task");
+		expect(runTask).toBeDefined();
+		if (!runTask) {
+			throw new Error("Expected team_run_task tool to be defined");
+		}
+
+		const ctx = { agentId: "lead", conversationId: "conv-1", iteration: 1 };
+
+		// Fire sync calls to two different agents - both should proceed
+		const call1 = runTask.execute(
+			{ agentId: "educator", task: "Explain probability", runMode: "sync" },
+			ctx,
+		);
+		const call2 = runTask.execute(
+			{ agentId: "assessor", task: "Evaluate answer", runMode: "sync" },
+			ctx,
+		);
+
+		// Both should have called routeToTeammate
+		expect(routeToTeammate).toHaveBeenCalledTimes(2);
+
+		// Resolve both
+		resolveRoute1({ text: "Explained", iterations: 2 });
+		resolveRoute2({ text: "Evaluated", iterations: 1 });
+
+		const result1 = (await call1) as { text?: string };
+		const result2 = (await call2) as { text?: string };
+		expect(result1.text).toBe("Explained");
+		expect(result2.text).toBe("Evaluated");
+	});
+
 	it("lists ready-to-claim tasks through team_task list action", async () => {
 		const runtime = new AgentTeamsRuntime({ teamName: "test-team" });
 		const tools = createAgentTeamsTools({

package/src/team/team-tools.ts

@@ -383,6 +383,11 @@ export function createAgentTeamsTools(
 		}) as Tool,
 	);
 
+	// Track in-flight sync runs per agent for dedup
+	// (Claude sometimes emits duplicate tool_use blocks in a single response;
+	//  we execute the first and return an informative "duplicate ignored" to the rest)
+	const pendingSyncRuns = new Set<string>();
+
 	tools.push(
 		createTool<
 			TeamRunTaskInput,
@@ -417,22 +422,36 @@ export function createAgentTeamsTools(
 						runId: run.id,
 					};
 				}
-				const result = await options.runtime.routeToTeammate(
-					validatedInput.agentId,
-					validatedInput.task,
-					{
-						taskId: validatedInput.taskId || undefined,
-						fromAgentId: options.requesterId,
-						continueConversation:
-							validatedInput.continueConversation || undefined,
-					},
-				);
-				return {
-					agentId: validatedInput.agentId,
-					mode: "sync",
-					text: result.text,
-					iterations: result.iterations,
-				};
+
+				/// Deduplication guard: reject a duplicate sync call for the same agent
+				// that was already dispatched in this same parallel tool-call batch.
+				if (pendingSyncRuns.has(validatedInput.agentId)) {
+					throw new Error(
+						`Duplicate team_run_task call detected for agent "${validatedInput.agentId}". ` +
+							`Only one call per agent is allowed per turn. Discard this duplicate result.`,
+					);
+				}
+				pendingSyncRuns.add(validatedInput.agentId);
+				try {
+					const result = await options.runtime.routeToTeammate(
+						validatedInput.agentId,
+						validatedInput.task,
+						{
+							taskId: validatedInput.taskId || undefined,
+							fromAgentId: options.requesterId,
+							continueConversation:
+								validatedInput.continueConversation || undefined,
+						},
+					);
+					return {
+						agentId: validatedInput.agentId,
+						mode: "sync",
+						text: result.text,
+						iterations: result.iterations,
+					};
+				} finally {
+					pendingSyncRuns.delete(validatedInput.agentId);
+				}
 			},
 		}) as Tool,
 	);

package/src/types/config.ts

@@ -42,6 +42,7 @@ export interface CoreRuntimeFeatures {
 	enableTools: boolean;
 	enableSpawnAgent: boolean;
 	enableAgentTeams: boolean;
+	disableMcpSettingsTools?: boolean;
 	yolo?: boolean;
 }
 

package/dist/runtime/team-runtime-registry.d.ts

@@ -1,13 +0,0 @@
-import type { AgentTeamsRuntime, DelegatedAgentConfigProvider } from "../team";
-export interface TeamRuntimeRegistryEntry {
-    runtime?: AgentTeamsRuntime;
-    delegatedAgentConfigProvider: DelegatedAgentConfigProvider;
-}
-export declare class TeamRuntimeRegistry {
-    private readonly entries;
-    get(key: string): TeamRuntimeRegistryEntry | undefined;
-    getOrCreate(key: string, create: () => TeamRuntimeRegistryEntry): TeamRuntimeRegistryEntry;
-    update(key: string, updateEntry: (entry: TeamRuntimeRegistryEntry) => void): TeamRuntimeRegistryEntry | undefined;
-    delete(key: string): void;
-}
-//# sourceMappingURL=team-runtime-registry.d.ts.map

package/dist/runtime/team-runtime-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"team-runtime-registry.d.ts","sourceRoot":"","sources":["../../src/runtime/team-runtime-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAE/E,MAAM,WAAW,wBAAwB;IACxC,OAAO,CAAC,EAAE,iBAAiB,CAAC;IAC5B,4BAA4B,EAAE,4BAA4B,CAAC;CAC3D;AAED,qBAAa,mBAAmB;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA+C;IAEvE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS;IAItD,WAAW,CACV,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,wBAAwB,GACpC,wBAAwB;IAU3B,MAAM,CACL,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,CAAC,KAAK,EAAE,wBAAwB,KAAK,IAAI,GACpD,wBAAwB,GAAG,SAAS;IASvC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;CAGzB"}

package/src/runtime/team-runtime-registry.ts

@@ -1,43 +0,0 @@
-import type { AgentTeamsRuntime, DelegatedAgentConfigProvider } from "../team";
-
-export interface TeamRuntimeRegistryEntry {
-	runtime?: AgentTeamsRuntime;
-	delegatedAgentConfigProvider: DelegatedAgentConfigProvider;
-}
-
-export class TeamRuntimeRegistry {
-	private readonly entries = new Map<string, TeamRuntimeRegistryEntry>();
-
-	get(key: string): TeamRuntimeRegistryEntry | undefined {
-		return this.entries.get(key);
-	}
-
-	getOrCreate(
-		key: string,
-		create: () => TeamRuntimeRegistryEntry,
-	): TeamRuntimeRegistryEntry {
-		const existing = this.entries.get(key);
-		if (existing) {
-			return existing;
-		}
-		const created = create();
-		this.entries.set(key, created);
-		return created;
-	}
-
-	update(
-		key: string,
-		updateEntry: (entry: TeamRuntimeRegistryEntry) => void,
-	): TeamRuntimeRegistryEntry | undefined {
-		const entry = this.entries.get(key);
-		if (!entry) {
-			return undefined;
-		}
-		updateEntry(entry);
-		return entry;
-	}
-
-	delete(key: string): void {
-		this.entries.delete(key);
-	}
-}