@clinebot/core 0.0.0 → 0.0.3

package/src/runtime/runtime-builder.test.ts

@@ -74,6 +74,75 @@ describe("DefaultRuntimeBuilder", () => {
 		expect(names).not.toContain("editor");
 	});
 
+	it("uses apply_patch instead of editor for codex/gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "openai",
+				modelId: "openai/gpt-5.4",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
+	it("keeps editor for non-codex/non-gpt model IDs in act mode", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("editor");
+		expect(names).not.toContain("apply_patch");
+	});
+
+	it("applies custom tool routing rules from session config", () => {
+		const runtime = new DefaultRuntimeBuilder().build({
+			config: {
+				providerId: "anthropic",
+				modelId: "claude-sonnet-4-6",
+				apiKey: "key",
+				systemPrompt: "test",
+				cwd: process.cwd(),
+				mode: "act",
+				enableTools: true,
+				enableSpawnAgent: false,
+				enableAgentTeams: false,
+				toolRoutingRules: [
+					{
+						mode: "act",
+						providerIdIncludes: ["anthropic"],
+						modelIdIncludes: ["claude"],
+						enableTools: ["apply_patch"],
+						disableTools: ["editor"],
+					},
+				],
+			},
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).toContain("apply_patch");
+		expect(names).not.toContain("editor");
+	});
+
 	it("omits builtin tools when disabled", () => {
 		const runtime = new DefaultRuntimeBuilder().build({
 			config: {

package/src/runtime/runtime-builder.ts

@@ -16,9 +16,12 @@ import {
 } from "../agents";
 import {
 	createBuiltinTools,
+	DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	resolveToolRoutingConfig,
 	type SkillsExecutor,
 	type ToolExecutors,
 	ToolPresets,
+	type ToolRoutingRule,
 } from "../default-tools";
 import { SqliteTeamStore } from "../storage/sqlite-team-store";
 import type { CoreAgentMode, CoreSessionConfig } from "../types/config";
@@ -47,15 +50,26 @@ export function createTeamName(): string {
 
 function createBuiltinToolsList(
 	cwd: string,
+	providerId: string,
 	mode: CoreAgentMode,
+	modelId: string,
+	toolRoutingRules: ToolRoutingRule[] | undefined,
 	skillsExecutor?: SkillsExecutorWithMetadata,
 	executorOverrides?: Partial<ToolExecutors>,
 ): Tool[] {
 	const preset =
 		mode === "plan" ? ToolPresets.readonly : ToolPresets.development;
+	const toolRoutingConfig = resolveToolRoutingConfig(
+		providerId,
+		modelId,
+		mode,
+		toolRoutingRules ?? DEFAULT_MODEL_TOOL_ROUTING_RULES,
+	);
+
 	return createBuiltinTools({
 		cwd,
 		...preset,
+		...toolRoutingConfig,
 		enableSkills: !!skillsExecutor,
 		executors: {
 			...(skillsExecutor
@@ -338,7 +352,10 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 			tools.push(
 				...createBuiltinToolsList(
 					config.cwd,
+					config.providerId,
 					normalized.mode,
+					config.modelId,
+					config.toolRoutingRules,
 					skillsExecutor,
 					defaultToolExecutors,
 				),
@@ -416,7 +433,10 @@ export class DefaultRuntimeBuilder implements RuntimeBuilder {
 						? () =>
 								createBuiltinToolsList(
 									config.cwd,
+									config.providerId,
 									normalized.mode,
+									config.modelId,
+									config.toolRoutingRules,
 									skillsExecutor,
 									defaultToolExecutors,
 								)

package/src/runtime/runtime-parity.test.ts

@@ -45,6 +45,13 @@ function legacyBuildRuntimeEnvironment(
 	return tools;
 }
 
+function normalizeParityToolNames(toolNames: string[]): string[] {
+	// Skills are discovered from user/workspace config and can appear in tests
+	// depending on the machine state. They are intentionally excluded from
+	// strict legacy parity checks.
+	return toolNames.filter((toolName) => toolName !== "skills");
+}
+
 function makeEmptyWorkspaceCwd(): string {
 	return mkdtempSync(join(tmpdir(), "runtime-parity-"));
 }
@@ -71,8 +78,10 @@ describe("runtime tool parity", () => {
 			enableAgentTeams: false,
 		};
 		const createSpawnTool = makeSpawnTool;
-		const expected = legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({
@@ -81,7 +90,7 @@ describe("runtime tool parity", () => {
 			})
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
 	it("matches legacy tool list when only spawn is enabled", () => {
@@ -96,8 +105,10 @@ describe("runtime tool parity", () => {
 			enableAgentTeams: false,
 		};
 		const createSpawnTool = makeSpawnTool;
-		const expected = legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config, createSpawnTool).map(
+				(tool) => tool.name,
+			),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({
@@ -106,7 +117,7 @@ describe("runtime tool parity", () => {
 			})
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 
 	it("matches legacy tool list when tools+spawn are disabled", () => {
@@ -120,13 +131,13 @@ describe("runtime tool parity", () => {
 			enableSpawnAgent: false,
 			enableAgentTeams: false,
 		};
-		const expected = legacyBuildRuntimeEnvironment(config).map(
-			(tool) => tool.name,
+		const expected = normalizeParityToolNames(
+			legacyBuildRuntimeEnvironment(config).map((tool) => tool.name),
 		);
 		const actual = new DefaultRuntimeBuilder()
 			.build({ config })
 			.tools.map((tool) => tool.name);
 
-		expect(actual).toEqual(expected);
+		expect(normalizeParityToolNames(actual)).toEqual(expected);
 	});
 });

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

@@ -155,14 +155,24 @@ class LocalFileSessionService {
 	persistSessionMessages(
 		sessionId: string,
 		messages: LlmsProviders.Message[],
+		systemPrompt?: string,
 	): void {
 		const row = this.rows.get(sessionId);
 		if (!row?.messages_path) {
 			throw new Error(`session not found: ${sessionId}`);
 		}
+		const payload: {
+			version: number;
+			updated_at: string;
+			systemPrompt?: string;
+			messages: LlmsProviders.Message[];
+		} = { version: 1, updated_at: nowIso(), messages };
+		if (systemPrompt !== undefined && systemPrompt !== "") {
+			payload.systemPrompt = systemPrompt;
+		}
 		writeFileSync(
 			row.messages_path,
-			`${JSON.stringify({ version: 1, updated_at: nowIso(), messages }, null, 2)}\n`,
+			`${JSON.stringify(payload, null, 2)}\n`,
 			"utf8",
 		);
 	}

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

@@ -237,6 +237,75 @@ describe("DefaultSessionManager", () => {
 		});
 	});
 
+	it("persists rendered messages when a turn fails", async () => {
+		const sessionId = "sess-failed-turn";
+		const manifest = createManifest(sessionId);
+		const persistSessionMessages = vi.fn();
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-failed-turn.json",
+				transcriptPath: "/tmp/transcript-failed-turn.log",
+				hookPath: "/tmp/hook-failed-turn.log",
+				messagesPath: "/tmp/messages-failed-turn.json",
+				manifest,
+			}),
+			persistSessionMessages,
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const renderedMessages = [
+			{ role: "user", content: [{ type: "text", text: "hello" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial" }] },
+		];
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockRejectedValue(new Error("boom")),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					restore: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi
+						.fn()
+						.mockReturnValueOnce([])
+						.mockReturnValue(renderedMessages),
+					messages: [],
+				}) as never,
+		});
+
+		await expect(
+			manager.start({
+				config: createConfig({ sessionId }),
+				prompt: "hello",
+				interactive: false,
+			}),
+		).rejects.toThrow("boom");
+
+		expect(persistSessionMessages).toHaveBeenCalledTimes(1);
+		expect(persistSessionMessages).toHaveBeenCalledWith(
+			sessionId,
+			renderedMessages,
+			"You are a test agent",
+		);
+		expect(sessionService.updateSessionStatus).toHaveBeenCalledWith(
+			sessionId,
+			"failed",
+			1,
+		);
+	});
+
 	it("uses run for first send then continue for subsequent sends", async () => {
 		const sessionId = "sess-2";
 		const manifest = createManifest(sessionId);
@@ -294,6 +363,123 @@ describe("DefaultSessionManager", () => {
 		expect(sessionService.persistSessionMessages).toHaveBeenCalledTimes(2);
 	});
 
+	it("tracks accumulated usage per session across turns", async () => {
+		const sessionId = "sess-usage";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-usage.json",
+				transcriptPath: "/tmp/transcript-usage.log",
+				hookPath: "/tmp/hook-usage.log",
+				messagesPath: "/tmp/messages-usage.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+		};
+		const runtimeBuilder = {
+			build: vi.fn().mockReturnValue({
+				tools: [],
+				shutdown: vi.fn(),
+			}),
+		};
+		const run = vi.fn().mockResolvedValue(
+			createResult({
+				text: "first",
+				usage: {
+					inputTokens: 10,
+					outputTokens: 3,
+					cacheReadTokens: 1,
+					cacheWriteTokens: 2,
+					totalCost: 0.11,
+				},
+			}),
+		);
+		const continueFn = vi.fn().mockResolvedValue(
+			createResult({
+				text: "second",
+				usage: {
+					inputTokens: 8,
+					outputTokens: 4,
+					cacheReadTokens: 2,
+					cacheWriteTokens: 0,
+					totalCost: 0.09,
+				},
+			}),
+		);
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run,
+					continue: continueFn,
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			interactive: true,
+		});
+
+		await manager.send({ sessionId, prompt: "first" });
+		expect(await manager.getAccumulatedUsage(sessionId)).toEqual({
+			inputTokens: 10,
+			outputTokens: 3,
+			cacheReadTokens: 1,
+			cacheWriteTokens: 2,
+			totalCost: 0.11,
+		});
+
+		await manager.send({ sessionId, prompt: "second" });
+		expect(await manager.getAccumulatedUsage(sessionId)).toEqual({
+			inputTokens: 18,
+			outputTokens: 7,
+			cacheReadTokens: 3,
+			cacheWriteTokens: 2,
+			totalCost: 0.2,
+		});
+	});
+
+	it("returns undefined accumulated usage for unknown sessions", async () => {
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: {
+				ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+				listSessions: vi.fn().mockResolvedValue([]),
+				deleteSession: vi.fn().mockResolvedValue({ deleted: false }),
+			} as never,
+			runtimeBuilder: {
+				build: vi.fn().mockReturnValue({
+					tools: [],
+					shutdown: vi.fn(),
+				}),
+			},
+			createAgent: () =>
+				({
+					run: vi.fn(),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		expect(
+			await manager.getAccumulatedUsage("missing-session"),
+		).toBeUndefined();
+	});
+
 	it("marks a failed single-run session as failed when run throws", async () => {
 		const sessionId = "sess-fail";
 		const manifest = createManifest(sessionId);
@@ -813,4 +999,88 @@ describe("DefaultSessionManager", () => {
 			0,
 		);
 	});
+
+	it("persists failed teammate task messages for team-task sub-sessions", async () => {
+		const sessionId = "sess-team-task-failure-messages";
+		const manifest = createManifest(sessionId);
+		const sessionService = {
+			ensureSessionsDir: vi.fn().mockReturnValue("/tmp/sessions"),
+			createRootSessionWithArtifacts: vi.fn().mockResolvedValue({
+				manifestPath: "/tmp/manifest-team-task-failure-messages.json",
+				transcriptPath: "/tmp/transcript-team-task-failure-messages.log",
+				hookPath: "/tmp/hook-team-task-failure-messages.log",
+				messagesPath: "/tmp/messages-team-task-failure-messages.json",
+				manifest,
+			}),
+			persistSessionMessages: vi.fn(),
+			updateSessionStatus: vi.fn().mockResolvedValue({ updated: true }),
+			writeSessionManifest: vi.fn(),
+			listSessions: vi.fn().mockResolvedValue([]),
+			deleteSession: vi.fn().mockResolvedValue({ deleted: true }),
+			onTeamTaskStart: vi.fn().mockResolvedValue(undefined),
+			onTeamTaskEnd: vi.fn().mockResolvedValue(undefined),
+		};
+
+		let onTeamEvent: ((event: unknown) => void) | undefined;
+		const runtimeBuilder = {
+			build: vi
+				.fn()
+				.mockImplementation(
+					(input: { onTeamEvent?: (event: unknown) => void }) => {
+						onTeamEvent = input.onTeamEvent;
+						return {
+							tools: [],
+							shutdown: vi.fn(),
+						};
+					},
+				),
+		};
+
+		const failedMessages = [
+			{ role: "user", content: [{ type: "text", text: "delegated prompt" }] },
+			{ role: "assistant", content: [{ type: "text", text: "partial work" }] },
+		];
+		const manager = new DefaultSessionManager({
+			distinctId,
+			sessionService: sessionService as never,
+			runtimeBuilder,
+			createAgent: () =>
+				({
+					run: vi.fn().mockImplementation(async () => {
+						onTeamEvent?.({
+							type: "task_start",
+							agentId: "providers-investigator",
+							message: "Investigate provider boundaries",
+						});
+						onTeamEvent?.({
+							type: "task_end",
+							agentId: "providers-investigator",
+							error: new Error("401 Unauthorized"),
+							messages: failedMessages,
+						});
+						return createResult({ text: "lead handled failure" });
+					}),
+					continue: vi.fn(),
+					abort: vi.fn(),
+					shutdown: vi.fn().mockResolvedValue(undefined),
+					getMessages: vi.fn().mockReturnValue([]),
+					messages: [],
+				}) as never,
+		});
+
+		await manager.start({
+			config: createConfig({ sessionId }),
+			prompt: "run teammate work",
+			interactive: false,
+		});
+
+		expect(sessionService.onTeamTaskStart).toHaveBeenCalledTimes(1);
+		expect(sessionService.onTeamTaskEnd).toHaveBeenCalledWith(
+			sessionId,
+			"providers-investigator",
+			"failed",
+			"[error] 401 Unauthorized",
+			failedMessages,
+		);
+	});
 });