@clinebot/core 0.0.34 → 0.0.36

package/src/{team → extensions/tools/team}/team-tools.ts

@@ -4,12 +4,11 @@ import {
 	TEAM_AWAIT_TIMEOUT_MS,
 	TEAM_RUN_MESSAGE_PREVIEW_LIMIT,
 	TEAM_RUN_TEXT_PREVIEW_LIMIT,
+	TEAM_TASK_IGNORED_FIELDS_BY_ACTION,
 	type TeamAttachOutcomeFragmentInput,
 	TeamAttachOutcomeFragmentInputSchema,
-	type TeamAwaitAllRunsInput,
-	TeamAwaitAllRunsInputSchema,
-	type TeamAwaitRunInput,
-	TeamAwaitRunInputSchema,
+	type TeamAwaitRunsInput,
+	TeamAwaitRunsInputSchema,
 	type TeamBroadcastInput,
 	TeamBroadcastInputSchema,
 	type TeamCancelRunInput,
@@ -24,8 +23,8 @@ import {
 	TeamListOutcomesInputSchema,
 	type TeamListRunsInput,
 	TeamListRunsInputSchema,
-	type TeamLogUpdateInput,
-	TeamLogUpdateInputSchema,
+	type TeamMissionLogInput,
+	TeamMissionLogInputSchema,
 	type TeamReadMailboxInput,
 	TeamReadMailboxInputSchema,
 	type TeamReviewOutcomeFragmentInput,
@@ -113,6 +112,24 @@ function summarizeRun(run: TeamRunRecord): TeamRunToolSummary {
 	};
 }
 
+function assertAwaitedRunSucceeded(run: TeamRunRecord): void {
+	if (run.status === "failed") {
+		throw new Error(
+			`Run "${run.id}" failed${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+	if (run.status === "cancelled") {
+		throw new Error(
+			`Run "${run.id}" was cancelled${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+	if (run.status === "interrupted") {
+		throw new Error(
+			`Run "${run.id}" was interrupted${run.error ? `: ${run.error}` : ""}`,
+		);
+	}
+}
+
 export type TeamTeammateRuntimeConfig = DelegatedAgentRuntimeConfig;
 
 export interface CreateAgentTeamsToolsOptions {
@@ -144,6 +161,27 @@ export interface BootstrapAgentTeamsResult {
 	restoredTeammates: string[];
 }
 
+export const TEAM_TOOL_NAMES = [
+	"team_spawn_teammate",
+	"team_shutdown_teammate",
+	"team_status",
+	"team_task",
+	"team_run_task",
+	"team_cancel_run",
+	"team_list_runs",
+	"team_await_runs",
+	"team_send_message",
+	"team_broadcast",
+	"team_read_mailbox",
+	"team_mission_log",
+	"team_cleanup",
+	"team_create_outcome",
+	"team_attach_outcome_fragment",
+	"team_review_outcome_fragment",
+	"team_finalize_outcome",
+	"team_list_outcomes",
+] as const;
+
 function spawnTeamTeammate(
 	options: Omit<CreateAgentTeamsToolsOptions, "requesterId" | "allowSpawn"> & {
 		requesterId: string;
@@ -244,7 +282,6 @@ export function createAgentTeamsTools(
 					const spec: TeamTeammateSpec = {
 						agentId: validatedInput.agentId,
 						rolePrompt: validatedInput.rolePrompt,
-						maxIterations: validatedInput.maxIterations,
 					};
 					spawnTeamTeammate({
 						runtime: options.runtime,
@@ -312,12 +349,26 @@ export function createAgentTeamsTools(
 		createTool<TeamTaskInput, TeamTaskToolResult>({
 			name: "team_task",
 			description:
-				"Manage shared team tasks. Use action=create|list|claim|complete|block.",
+				"Manage shared team tasks with action-specific payloads. " +
+				"create requires title and description, with optional dependsOn and assignee. " +
+				"list accepts optional status, assignee. " +
+				"claim requires taskId. complete requires taskId and summary. block requires taskId and reason. " +
+				"Do not include fields from other actions.",
 			inputSchema: zodToJsonSchema(TeamTaskInputSchema),
 			execute: async (input) => {
 				const validatedInput = validateWithZod(TeamTaskInputSchema, input);
 				switch (validatedInput.action) {
 					case "create": {
+						const ignoredFieldSet = new Set(
+							TEAM_TASK_IGNORED_FIELDS_BY_ACTION.create ?? [],
+						);
+						const ignoredFields = Object.entries(
+							input as Record<string, unknown>,
+						)
+							.filter(
+								([field, value]) => ignoredFieldSet.has(field) && value != null,
+							)
+							.map(([field]) => field);
 						const task = options.runtime.createTask({
 							title: validatedInput.title!,
 							description: validatedInput.description!,
@@ -329,6 +380,12 @@ export function createAgentTeamsTools(
 							action: "create",
 							taskId: task.id,
 							status: task.status,
+							...(ignoredFields.length > 0
+								? {
+										ignoredFields,
+										note: `Ignored fields for action=create: ${ignoredFields.join(", ")}`,
+									}
+								: {}),
 						};
 					}
 					case "list":
@@ -337,8 +394,6 @@ export function createAgentTeamsTools(
 							tasks: options.runtime.listTaskItems({
 								status: validatedInput.status,
 								assignee: validatedInput.assignee,
-								unassignedOnly: validatedInput.unassignedOnly,
-								readyOnly: validatedInput.readyOnly,
 							}),
 						};
 					case "claim": {
@@ -486,44 +541,19 @@ export function createAgentTeamsTools(
 	);
 
 	tools.push(
-		createTool<TeamAwaitRunInput, TeamRunToolSummary>({
-			name: "team_await_run",
+		createTool<TeamAwaitRunsInput, TeamRunToolSummary | TeamRunToolSummary[]>({
+			name: "team_await_runs",
 			description:
-				"Wait for one async run by runId. Uses a long timeout for legitimate teammate work.",
-			inputSchema: zodToJsonSchema(TeamAwaitRunInputSchema),
+				"Wait for async teammate runs. Provide runId to wait for one run, or omit it to wait for all active async runs. Uses a long timeout for legitimate teammate work.",
+			inputSchema: zodToJsonSchema(TeamAwaitRunsInputSchema),
 			timeoutMs: TEAM_AWAIT_TIMEOUT_MS,
 			execute: async (input) => {
-				const validatedInput = validateWithZod(TeamAwaitRunInputSchema, input);
-				const run = await options.runtime.awaitRun(validatedInput.runId);
-				if (run.status === "failed") {
-					throw new Error(
-						`Run "${run.id}" failed${run.error ? `: ${run.error}` : ""}`,
-					);
-				}
-				if (run.status === "cancelled") {
-					throw new Error(
-						`Run "${run.id}" was cancelled${run.error ? `: ${run.error}` : ""}`,
-					);
-				}
-				if (run.status === "interrupted") {
-					throw new Error(
-						`Run "${run.id}" was interrupted${run.error ? `: ${run.error}` : ""}`,
-					);
+				const validatedInput = validateWithZod(TeamAwaitRunsInputSchema, input);
+				if (validatedInput.runId) {
+					const run = await options.runtime.awaitRun(validatedInput.runId);
+					assertAwaitedRunSucceeded(run);
+					return summarizeRun(run);
 				}
-				return summarizeRun(run);
-			},
-		}) as Tool,
-	);
-
-	tools.push(
-		createTool<TeamAwaitAllRunsInput, TeamRunToolSummary[]>({
-			name: "team_await_all_runs",
-			description:
-				"Wait for all active async runs to complete. Uses a long timeout for legitimate teammate work.",
-			inputSchema: zodToJsonSchema(TeamAwaitAllRunsInputSchema),
-			timeoutMs: TEAM_AWAIT_TIMEOUT_MS,
-			execute: async (input) => {
-				validateWithZod(TeamAwaitAllRunsInputSchema, input);
 				const runs = await options.runtime.awaitAllRuns();
 				const failedRuns = runs.filter((run) =>
 					["failed", "cancelled", "interrupted"].includes(run.status),
@@ -547,7 +577,7 @@ export function createAgentTeamsTools(
 	tools.push(
 		createTool<TeamSendMessageInput, { id: string; toAgentId: string }>({
 			name: "team_send_message",
-			description: "Send a direct mailbox message to one teammate.",
+			description: "Send a mailbox message to a specific teammate.",
 			inputSchema: zodToJsonSchema(TeamSendMessageInputSchema),
 			execute: async (input) => {
 				const validatedInput = validateWithZod(
@@ -569,7 +599,7 @@ export function createAgentTeamsTools(
 	tools.push(
 		createTool<TeamBroadcastInput, { delivered: number }>({
 			name: "team_broadcast",
-			description: "Broadcast a mailbox message to all teammates.",
+			description: "Broadcast a message to all teammates.",
 			inputSchema: zodToJsonSchema(TeamBroadcastInputSchema),
 			execute: async (input) => {
 				const validatedInput = validateWithZod(TeamBroadcastInputSchema, input);
@@ -579,7 +609,6 @@ export function createAgentTeamsTools(
 					validatedInput.body,
 					{
 						taskId: validatedInput.taskId ?? undefined,
-						includeLead: validatedInput.includeLead ?? undefined,
 					},
 				);
 				return { delivered: messages.length };
@@ -602,7 +631,6 @@ export function createAgentTeamsTools(
 				);
 				return options.runtime.listMailbox(options.requesterId, {
 					unreadOnly: validatedInput.unreadOnly,
-					limit: validatedInput.limit,
 					markRead: true,
 				});
 			},
@@ -610,12 +638,15 @@ export function createAgentTeamsTools(
 	);
 
 	tools.push(
-		createTool<TeamLogUpdateInput, { id: string }>({
-			name: "team_log_update",
-			description: "Append a mission log update for this agent.",
-			inputSchema: zodToJsonSchema(TeamLogUpdateInputSchema),
+		createTool<TeamMissionLogInput, { id: string }>({
+			name: "team_mission_log",
+			description: "Append a mission log update for your team.",
+			inputSchema: zodToJsonSchema(TeamMissionLogInputSchema),
 			execute: async (input) => {
-				const validatedInput = validateWithZod(TeamLogUpdateInputSchema, input);
+				const validatedInput = validateWithZod(
+					TeamMissionLogInputSchema,
+					input,
+				);
 				const entry = options.runtime.appendMissionLog({
 					agentId: options.requesterId,
 					taskId: validatedInput.taskId || undefined,

package/src/{tools → extensions/tools}/types.ts

@@ -4,7 +4,7 @@
  * Type definitions for executors, configuration, and results.
  */
 
-import type { ToolContext } from "@clinebot/shared";
+import type { ImageContent, TextContent, ToolContext } from "@clinebot/shared";
 import type {
 	ApplyPatchInput,
 	EditFileInput,
@@ -23,7 +23,7 @@ export interface ToolOperationResult {
 	/** The query/input that was executed */
 	query: string;
 	/** The result content (if successful) */
-	result: string;
+	result: unknown;
 	/** Error message (if failed) */
 	error?: string;
 	/** Whether the operation succeeded */
@@ -32,6 +32,8 @@ export interface ToolOperationResult {
 	duration?: number;
 }
 
+export type FileReadResultContent = string | Array<TextContent | ImageContent>;
+
 // =============================================================================
 // Executor Interfaces
 // =============================================================================
@@ -46,7 +48,7 @@ export interface ToolOperationResult {
 export type FileReadExecutor = (
 	request: ReadFileRequest,
 	context: ToolContext,
-) => Promise<string>;
+) => Promise<FileReadResultContent>;
 
 /**
  * Executor for searching the codebase

package/src/{runtime → hooks}/checkpoint-hooks.ts

@@ -86,6 +86,33 @@ async function runGit(
 	};
 }
 
+/**
+ * Deletes all private git refs under refs/cline/checkpoints/{sessionId}/ that
+ * were created by the checkpoint system to keep stash objects reachable.
+ * Errors are swallowed — if the cwd is not a git repo or the refs don't exist,
+ * the delete is a no-op.
+ */
+export async function deleteCheckpointRefs(
+	cwd: string | null | undefined,
+	sessionId: string,
+): Promise<void> {
+	if (!cwd) return;
+	const prefix = `refs/cline/checkpoints/${sessionId}/`;
+	try {
+		const { stdout } = await runGit(cwd, [
+			"for-each-ref",
+			"--format=%(refname)",
+			prefix,
+		]);
+		const refs = stdout.trim().split("\n").filter(Boolean);
+		await Promise.allSettled(
+			refs.map((ref) => runGit(cwd, ["update-ref", "-d", ref])),
+		);
+	} catch {
+		// Not a git repo or git not available — ignore.
+	}
+}
+
 export function createCheckpointHooks(
 	options: CreateCheckpointHooksOptions,
 ): AgentHooks {

package/src/{runtime → hooks}/hook-file-hooks.ts

@@ -1,13 +1,15 @@
 import { spawn } from "node:child_process";
 import { appendFileSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import type { AgentHooks } from "@clinebot/agents";
 import {
 	augmentNodeCommandForDebug,
 	type BasicLogger,
 	type HookSessionContext,
+	type WorkspaceInfo,
 	withResolvedClineBuildEnv,
 } from "@clinebot/shared";
-import { ensureParentDir } from "@clinebot/shared/storage";
+import { ensureHookLogDir } from "@clinebot/shared/storage";
 import { listHookConfigFiles } from "../extensions/config/hooks-config-loader";
 import type { HookEventName, HookEventPayload } from "../hooks";
 
@@ -42,10 +44,11 @@ type AgentHookSessionShutdownContext = Parameters<
 type HookRuntimeOptions = {
 	cwd: string;
 	workspacePath: string;
-	hookLogPath?: string;
 	rootSessionId?: string;
 	logger?: BasicLogger;
 	toolCallTimeoutMs?: number;
+	/** Structured git + path metadata forwarded into every hook payload. */
+	workspaceInfo?: WorkspaceInfo;
 };
 
 function mapParams(input: unknown): Record<string, string> {
@@ -147,10 +150,6 @@ function isAbortReason(reason?: string): boolean {
 	);
 }
 
-function ensureHookLogDir(filePath: string): void {
-	ensureParentDir(filePath);
-}
-
 function createPayloadBase(
 	ctx: HookContextBase,
 	options: HookRuntimeOptions,
@@ -159,7 +158,6 @@ function createPayloadBase(
 		process.env.CLINE_USER_ID?.trim() || process.env.USER?.trim() || "unknown";
 	const sessionContext: HookSessionContext = {
 		rootSessionId: options.rootSessionId || ctx.conversationId,
-		hookLogPath: options.hookLogPath,
 	};
 	return {
 		clineVersion: process.env.CLINE_VERSION?.trim() || "",
@@ -167,6 +165,7 @@ function createPayloadBase(
 		taskId: ctx.conversationId,
 		sessionContext,
 		workspaceRoots: options.workspacePath ? [options.workspacePath] : [],
+		workspaceInfo: options.workspaceInfo,
 		userId,
 		agent_id: ctx.agentId,
 		parent_agent_id: ctx.parentAgentId,
@@ -275,7 +274,7 @@ async function runHookCommand(
 	}
 	const command = augmentNodeCommandForDebug(options.command, {
 		env: options.env,
-		debugRole: "hook-worker",
+		debugRole: "hook",
 	});
 	const child = spawn(command[0], command.slice(1), {
 		cwd: options.cwd,
@@ -400,7 +399,7 @@ function inferHookCommand(path: string): string[] {
 		lowered.endsWith(".cjs")
 	) {
 		return augmentNodeCommandForDebug(["node", path], {
-			debugRole: "hook-worker",
+			debugRole: "hook",
 		});
 	}
 	if (
@@ -503,15 +502,15 @@ function runAsyncHookCommands(options: {
 }
 
 export function createHookAuditHooks(options: {
-	hookLogPath: string;
 	rootSessionId?: string;
 	workspacePath: string;
+	workspaceInfo?: WorkspaceInfo;
 }): AgentHooks {
 	const runtimeOptions: HookRuntimeOptions = {
 		cwd: options.workspacePath,
 		workspacePath: options.workspacePath,
-		hookLogPath: options.hookLogPath,
 		rootSessionId: options.rootSessionId,
+		workspaceInfo: options.workspaceInfo,
 	};
 
 	const append = (payload: HookEventPayload): void => {
@@ -519,8 +518,10 @@ export function createHookAuditHooks(options: {
 			ts: new Date().toISOString(),
 			...payload,
 		})}\n`;
-		ensureHookLogDir(options.hookLogPath);
-		appendFileSync(options.hookLogPath, line, "utf8");
+		const envPath = process.env.CLINE_HOOKS_LOG_PATH?.trim() || undefined;
+		const logPath = envPath ?? join(ensureHookLogDir(), "hooks.jsonl");
+		ensureHookLogDir(logPath);
+		appendFileSync(logPath, line, "utf8");
 	};
 
 	return {

package/src/hooks/index.ts

@@ -1,10 +1,3 @@
-export {
-	createPersistentSubprocessHooks,
-	PersistentHookClient,
-	type PersistentHookClientOptions,
-	type PersistentSubprocessHookControl,
-	type PersistentSubprocessHooksOptions,
-} from "./persistent";
 export {
 	createSubprocessHooks,
 	type HookEventName,

package/src/hooks/subprocess-runner.ts

@@ -113,7 +113,7 @@ export async function runSubprocessEvent(
 ): Promise<RunSubprocessEventResult | undefined> {
 	const command = augmentNodeCommandForDebug(options.command, {
 		env: options.env,
-		debugRole: "hook-worker",
+		debugRole: "hook",
 	});
 	if (!Array.isArray(command) || command.length === 0) {
 		throw new Error("runSubprocessEvent requires a non-empty command");