@selesai/code 0.8.3 → 0.8.4

package/dist/extensions/pi-subagents/src/shared/utils.ts

@@ -6,6 +6,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
+import { previewDisplayText, sanitizeDisplayText, truncateDisplayText } from "./display-text.ts";
 import { formatToolCall } from "./formatters.ts";
 import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, NestedRunSummary, SingleResult, ToolCallSummary, Usage } from "./types.ts";
 
@@ -101,6 +102,23 @@ export function getAgentDir(): string {
 
 const statusCache = new Map<string, { mtime: number; ctime: number; size: number; ino: number; status: AsyncStatus }>();
 
+export function pruneStatusCacheForAsyncRoot(asyncDirRoot: string, runIds: Iterable<string>): number {
+	const root = path.resolve(asyncDirRoot);
+	const currentStatusPaths = new Set(
+		Array.from(runIds, (runId) => path.resolve(root, runId, "status.json")),
+	);
+	let removed = 0;
+	for (const statusPath of statusCache.keys()) {
+		const resolved = path.resolve(statusPath);
+		const relative = path.relative(root, resolved);
+		if (relative && !relative.startsWith("..") && !path.isAbsolute(relative) && !currentStatusPaths.has(resolved)) {
+			statusCache.delete(statusPath);
+			removed++;
+		}
+	}
+	return removed;
+}
+
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -127,7 +145,10 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	try {
 		stat = fs.statSync(statusPath);
 	} catch (error) {
-		if (isNotFoundError(error)) return null;
+		if (isNotFoundError(error)) {
+			statusCache.delete(statusPath);
+			return null;
+		}
 		throw new Error(`Failed to inspect async status file '${statusPath}': ${getErrorMessage(error)}`, {
 			cause: error instanceof Error ? error : undefined,
 		});
@@ -148,7 +169,10 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	try {
 		content = fs.readFileSync(statusPath, "utf-8");
 	} catch (error) {
-		if (isNotFoundError(error)) return null;
+		if (isNotFoundError(error)) {
+			statusCache.delete(statusPath);
+			return null;
+		}
 		throw new Error(`Failed to read async status file '${statusPath}': ${getErrorMessage(error)}`, {
 			cause: error instanceof Error ? error : undefined,
 		});
@@ -170,10 +194,6 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 		ino: stat.ino,
 		status,
 	});
-	if (statusCache.size > 50) {
-		const firstKey = statusCache.keys().next().value;
-		if (firstKey) statusCache.delete(firstKey);
-	}
 	return status;
 }
 
@@ -522,11 +542,8 @@ export function detectSubagentError(messages: Message[]): ErrorInfo {
  * Extract a preview of tool arguments for display
  */
 export function extractToolArgsPreview(args: Record<string, unknown>): string {
-	const truncatePreview = (value: string, maxLength: number): string =>
-		value.length > maxLength ? `${value.slice(0, maxLength - 3)}...` : value;
-
 	const stringifyPreviewValue = (value: unknown): string | undefined => {
-		if (typeof value === "string" && value.trim().length > 0) return value;
+		if (typeof value === "string" && value.trim().length > 0) return sanitizeDisplayText(value);
 		if (typeof value === "number" || typeof value === "boolean") return String(value);
 		return undefined;
 	};
@@ -539,39 +556,32 @@ export function extractToolArgsPreview(args: Record<string, unknown>): string {
 		return `${first}${suffix}`;
 	};
 
-	// Handle MCP tool calls - show server/tool info
-	if (args.tool && typeof args.tool === "string") {
-		const server = args.server && typeof args.server === "string" ? `${args.server}/` : "";
-		const toolArgs = args.args && typeof args.args === "string" ? ` ${args.args.slice(0, 40)}` : "";
-		return `${server}${args.tool}${toolArgs}`;
+	if (typeof args.tool === "string") {
+		const server = typeof args.server === "string" ? `${sanitizeDisplayText(args.server)}/` : "";
+		const toolArgs = typeof args.args === "string" ? ` ${truncateDisplayText(sanitizeDisplayText(args.args), 40)}` : "";
+		return sanitizeDisplayText(`${server}${args.tool}${toolArgs}`);
 	}
 
 	const queriesPreview = previewArray(args.queries);
-	if (queriesPreview) return truncatePreview(queriesPreview, 60);
-	if (typeof args.query === "string" && args.query.trim().length > 0) return truncatePreview(args.query, 60);
-	if (typeof args.workflow === "string" && args.workflow.trim().length > 0) return `workflow=${truncatePreview(args.workflow, 48)}`;
+	if (queriesPreview) return previewDisplayText(queriesPreview, 60);
+	if (typeof args.query === "string" && args.query.trim().length > 0) return previewDisplayText(args.query, 60);
+	if (typeof args.workflow === "string" && args.workflow.trim().length > 0) return `workflow=${previewDisplayText(args.workflow, 48)}`;
 
-	if (typeof args.url === "string" && args.url.trim().length > 0) return truncatePreview(args.url, 60);
+	if (typeof args.url === "string" && args.url.trim().length > 0) return previewDisplayText(args.url, 60);
 	const urlsPreview = previewArray(args.urls);
-	if (urlsPreview) return truncatePreview(urlsPreview, 60);
-	if (typeof args.prompt === "string" && args.prompt.trim().length > 0) return truncatePreview(args.prompt, 60);
-	
+	if (urlsPreview) return previewDisplayText(urlsPreview, 60);
+	if (typeof args.prompt === "string" && args.prompt.trim().length > 0) return previewDisplayText(args.prompt, 60);
+
 	const previewKeys = ["command", "path", "file_path", "pattern", "query", "url", "task", "describe", "search"];
 	for (const key of previewKeys) {
-		if (args[key] && typeof args[key] === "string") {
-			const value = args[key] as string;
-			return truncatePreview(value, 60);
-		}
+		if (typeof args[key] === "string") return previewDisplayText(args[key], 60);
 	}
-	
-	// Fallback: show first string value found
+
 	for (const [key, value] of Object.entries(args)) {
+		const displayKey = sanitizeDisplayText(key);
 		const arrayPreview = previewArray(value);
-		if (arrayPreview) return `${key}=${truncatePreview(arrayPreview, 50)}`;
-		if (typeof value === "string" && value.length > 0) {
-			const preview = truncatePreview(value, 50);
-			return `${key}=${preview}`;
-		}
+		if (arrayPreview) return `${displayKey}=${previewDisplayText(arrayPreview, 50)}`;
+		if (typeof value === "string" && value.length > 0) return `${displayKey}=${previewDisplayText(value, 50)}`;
 	}
 	return "";
 }

package/dist/extensions/pi-subagents/src/slash/delegation-adapters.ts

@@ -251,7 +251,7 @@ export function toDelegationUpdate(requestId: string, update: PromptTemplateBrid
 				: undefined;
 		return {
 			index: entry.index,
-			agent: entry.agent ?? "explorer",
+			agent: entry.agent ?? "delegate",
 			status: entry.status,
 			currentTool: entry.currentTool,
 			currentToolArgs: entry.currentToolArgs,
@@ -286,19 +286,6 @@ export function toDelegationUpdate(requestId: string, update: PromptTemplateBrid
 	};
 }
 
-export function toLegacyExecutionParams(request: PromptTemplateDelegationRequest): DelegatedSubagentExecutionParams {
-	return {
-		agent: request.agent,
-		task: request.task,
-		context: request.context,
-		model: request.model,
-		cwd: request.cwd,
-		async: false,
-		foregroundOnly: true,
-		clarify: false,
-	};
-}
-
 export function toSubagentDelegationExecutionParams(request: SubagentDelegationRequest): DelegatedSubagentExecutionParams {
 	return {
 		agent: request.agent,

package/dist/extensions/pi-subagents/src/slash/inline-subagents.ts

@@ -103,7 +103,7 @@ export function createInlineSubagentAutocompleteProvider(
  */
 export function registerInlineSubagentInvocation(pi: ExtensionAPI, state: SubagentState): void {
 	pi.on("session_start", (_event, ctx) => {
-		ctx.ui.addAutocompleteProvider((current) => createInlineSubagentAutocompleteProvider(state, current));
+		ctx.ui.addAutocompleteProvider?.((current) => createInlineSubagentAutocompleteProvider(state, current));
 	});
 
 	pi.on("input", (event, ctx) => {

package/dist/extensions/pi-subagents/src/slash/prompt-template-bridge.ts

@@ -12,7 +12,6 @@ import { parseSubagentDelegationRequest } from "./delegation-request.ts";
 import {
 	parsePromptTemplateRequest,
 	toDelegationUpdate,
-	toLegacyExecutionParams,
 	toPromptTemplateResponse,
 	toSubagentDelegationExecutionParams,
 	toSubagentDelegationResponse,
@@ -183,22 +182,25 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 		} else {
 			if (data && typeof data === "object" && !Array.isArray(data)) {
 				const legacy = data as Record<string, unknown>;
-				if (legacy.tasks !== undefined || legacy.worktree !== undefined) {
-					if (typeof legacy.requestId === "string" && legacy.requestId) {
-						options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
-							requestId: legacy.requestId,
-							messages: [],
-							isError: true,
-							errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use workflowScript.",
-						});
-					}
+				if ((legacy.tasks !== undefined || legacy.worktree !== undefined) && typeof legacy.requestId === "string" && legacy.requestId) {
+					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+						requestId: legacy.requestId,
+						messages: [],
+						isError: true,
+						errorText: "Legacy prompt-template tasks/worktree orchestration was removed; use workflowScript.",
+					});
 					return;
 				}
 			}
 			legacyRequest = parsePromptTemplateRequest(data);
 			if (!legacyRequest) return;
-			requestId = legacyRequest.requestId;
-			params = toLegacyExecutionParams(legacyRequest);
+			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, {
+				...legacyRequest,
+				messages: [],
+				isError: true,
+				errorText: "Legacy prompt-template direct delegation was removed; use workflowScript through the subagent tool or structured delegation.",
+			} satisfies PromptTemplateDelegationResponse);
+			return;
 		}
 
 		if (!structuredRequest && legacyControllers.has(requestId)) return;

package/dist/extensions/pi-subagents/src/slash/prompt-workflows.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { parseFrontmatter } from "../agents/frontmatter.ts";
+import { discoverAgents, discoverAgentsAll, resolveAgentName, type ChainConfig, type ChainStepConfig } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { getAgentDir, getProjectConfigDir } from "../shared/utils.ts";
+import type { ChainStep } from "../shared/settings.ts";
+import { getPromptDirectories } from "../shared/prompt-resources.ts";
 
 interface PromptWorkflow {
 	name: string;
@@ -32,21 +33,9 @@ const RESERVED_COMMAND_NAMES = new Set([
 	"subagents-models",
 ]);
 
-function packagePromptsDir(): string {
-	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts");
-}
-
-function promptDirs(cwd: string): string[] {
-	return [
-		packagePromptsDir(),
-		path.join(getAgentDir(), "prompts"),
-		path.join(getProjectConfigDir(cwd), "prompts"),
-	];
-}
-
 function readPromptFiles(cwd: string): string[] {
 	const files: string[] = [];
-	for (const dir of promptDirs(cwd)) {
+	for (const dir of Object.values(getPromptDirectories(cwd))) {
 		let entries: fs.Dirent[];
 		try {
 			entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -85,7 +74,7 @@ function parseSkill(value: string | undefined): string | string[] | false | unde
 
 function parseAgent(frontmatter: Record<string, string>): string {
 	const subagent = stringField(frontmatter, "subagent");
-	if (!subagent || subagent === "true") return "explorer";
+	if (!subagent || subagent === "true") return "delegate";
 	return subagent;
 }
 
@@ -213,13 +202,19 @@ function workflowParams(workflow: PromptWorkflow, args: string[], runtime: Retur
 	return {
 		agent: runtime.agentOverride ?? workflow.agent,
 		task,
-		clarify: false,
 		agentScope: "both",
 		...(context ? { context } : {}),
 		...(workflow.model ? { model: workflow.model } : {}),
 		...(workflow.skill !== undefined ? { skill: workflow.skill } : {}),
 		...(workflow.cwd ? { cwd: workflow.cwd } : {}),
-		...(runtime.bg ? { async: true } : {}),
+	};
+}
+
+function promptWorkflowExecutionParams(workflows: PromptWorkflow[], args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): SubagentParamsLike {
+	return {
+		workflowScript: promptWorkflowScript(workflows, args, runtime),
+		agentScope: "both",
+		async: runtime.bg ? true : false,
 	};
 }
 
@@ -228,7 +223,7 @@ function promptWorkflowScript(workflows: PromptWorkflow[], args: string[], runti
 		const params = workflowParams(workflow, args, runtime);
 		const task = params.task ?? "";
 		const child = {
-			agent: params.agent ?? "explorer",
+			agent: params.agent ?? "delegate",
 			task,
 			...(params.model ? { model: params.model } : {}),
 			...(params.skill !== undefined ? { skill: params.skill } : {}),
@@ -252,6 +247,75 @@ function formatWorkflowList(workflows: PromptWorkflow[]): string {
 	].join("\n");
 }
 
+// --- Selesai additions: native chain / parallel / saved-chain slash commands ---
+
+/**
+ * Parse `agent task | agent task | ...` into chain steps. Runtime flags
+ * (`--bg`, `--fork`, `--fresh`) are stripped before splitting on `|`.
+ */
+function parseStepList(input: string): { agent: string; task: string }[] {
+	const words = shellWords(input);
+	const args: string[] = [];
+	let fork = false;
+	let fresh = false;
+	let bg = false;
+	for (let i = 0; i < words.length; i++) {
+		const word = words[i]!;
+		if (word === "--fork") { fork = true; continue; }
+		if (word === "--fresh") { fresh = true; continue; }
+		if (word === "--bg" || word === "--async") { bg = true; continue; }
+		args.push(word);
+	}
+	const steps: { agent: string; task: string }[] = [];
+	let current = "";
+	for (const word of args) {
+		if (word === "|") {
+			if (current.trim()) steps.push(parseStep(current));
+			current = "";
+			continue;
+		}
+		current += (current ? " " : "") + word;
+	}
+	if (current.trim()) steps.push(parseStep(current));
+	return steps.map((step) => ({ ...step, ...(fork ? { context: "fork" as const } : {}), ...(fresh ? { context: "fresh" as const } : {}) }));
+}
+
+function parseStep(stepText: string): { agent: string; task: string } {
+	const space = stepText.indexOf(" ");
+	if (space === -1) return { agent: stepText, task: "" };
+	return { agent: stepText.slice(0, space), task: stepText.slice(space + 1).trim() };
+}
+
+function resolveStepsAgents(steps: { agent: string; task: string }[], cwd: string): { agent: string; task: string }[] {
+	const agents = discoverAgents(cwd, "both").agents;
+	return steps.map((step) => {
+		const resolved = resolveAgentName(step.agent, agents);
+		if (resolved.error || !resolved.agent) throw new Error(`Unknown agent: ${step.agent}`);
+		return { agent: resolved.agent.name, task: step.task };
+	});
+}
+
+function normalizeChainStep(step: ChainStepConfig): Record<string, unknown> {
+	const normalized: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(step)) {
+		if (value === undefined) continue;
+		if (key === "skills") {
+			if (value !== false) normalized.skill = value;
+			continue;
+		}
+		normalized[key] = value;
+	}
+	return normalized;
+}
+
+function formatChainList(chains: ChainConfig[]): string {
+	if (chains.length === 0) return "No saved chains found in user or project chains.";
+	return [
+		"Saved chains:",
+		...chains.map((chain) => `- ${chain.name}: ${chain.description ?? chain.filePath}`),
+	].join("\n");
+}
+
 export function registerPromptWorkflowCommands(input: {
 	pi: ExtensionAPI;
 	run: PromptWorkflowRunner;
@@ -281,14 +345,105 @@ export function registerPromptWorkflowCommands(input: {
 						if (!step) throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
 						return step;
 					});
-					await run({ workflowScript: promptWorkflowScript(chain, runtime.args, runtime), clarify: false, agentScope: "both", ...(runtime.bg ? { async: true } : {}) }, ctx);
+					await run(promptWorkflowExecutionParams(chain, runtime.args, runtime), ctx);
+					return;
+				}
+				await run(promptWorkflowExecutionParams([workflow], runtime.args, runtime), ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("chain", {
+		description: "Launch a chain of steps: /chain <agent> <task> | <agent> <task> [--bg] [--fork] [--fresh]",
+		handler: async (rawArgs, ctx) => {
+			try {
+				const steps = resolveStepsAgents(parseStepList(rawArgs), ctx.cwd);
+				if (steps.length === 0) {
+					ctx.ui.notify("Usage: /chain <agent> <task> | <agent> <task> [--bg] [--fork] [--fresh]", "error");
 					return;
 				}
-				await run(workflowParams(workflow, runtime.args, runtime), ctx);
+				const bg = rawArgs.includes("--bg") || rawArgs.includes("--async");
+				await run({ chain: steps as ChainStep[], agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
 			} catch (error) {
 				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
 			}
 		},
 	});
 
+	pi.registerCommand("parallel", {
+		description: "Launch top-level parallel tasks: /parallel <agent> <task> | <agent> <task> [--bg]",
+		handler: async (rawArgs, ctx) => {
+			try {
+				const steps = resolveStepsAgents(parseStepList(rawArgs), ctx.cwd);
+				if (steps.length === 0) {
+					ctx.ui.notify("Usage: /parallel <agent> <task> | <agent> <task> [--bg]", "error");
+					return;
+				}
+				const bg = rawArgs.includes("--bg") || rawArgs.includes("--async");
+				await run({ tasks: steps, agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("run-chain", {
+		description: "Run a saved .chain.md/.chain.json workflow: /run-chain <name> [--bg]",
+		handler: async (rawArgs, ctx) => {
+			const words = shellWords(rawArgs);
+			const name = words.find((word) => !word.startsWith("--"));
+			const bg = words.includes("--bg") || words.includes("--async");
+			const chains = discoverAgentsAll(ctx.cwd).chains;
+			if (!name || name === "list") {
+				pi.sendMessage({ content: formatChainList(chains), display: true } as Parameters<typeof pi.sendMessage>[0]);
+				return;
+			}
+			const chain = chains.find((candidate) => candidate.name === name || candidate.localName === name);
+			if (!chain) {
+				ctx.ui.notify(`Unknown saved chain: ${name}`, "error");
+				return;
+			}
+			try {
+				await run({ chain: chain.steps.map(normalizeChainStep) as unknown as ChainStep[], agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("chain-prompts", {
+		description: "Run a prompt template whose frontmatter declares a chain, as a native chain: /chain-prompts <name> [args]",
+		handler: async (rawArgs, ctx) => {
+			const words = shellWords(rawArgs);
+			const name = words.shift();
+			const workflows = discoverPromptWorkflows(ctx.cwd);
+			if (!name || name === "list") {
+				pi.sendMessage({ content: formatWorkflowList(workflows), display: true } as Parameters<typeof pi.sendMessage>[0]);
+				return;
+			}
+			const workflow = findWorkflow(workflows, name);
+			if (!workflow) {
+				ctx.ui.notify(`Unknown prompt workflow: ${name}`, "error");
+				return;
+			}
+			const runtime = parseRuntimeOptions(words);
+			try {
+				if (workflow.chain) {
+					const steps = splitPromptChain(workflow.chain).map((stepName) => {
+						const step = findWorkflow(workflows, stepName);
+						if (!step) throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
+						const params = workflowParams(step, runtime.args, runtime);
+						return { agent: params.agent, task: params.task };
+					});
+					await run({ chain: steps as ChainStep[], agentScope: "both", ...(runtime.bg ? { async: true } : {}) }, ctx);
+					return;
+				}
+				ctx.ui.notify(`Prompt workflow '${name}' has no chain frontmatter; use /prompt-workflow for single-step templates.`, "warning");
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
 }

package/dist/extensions/pi-subagents/src/slash/slash-bridge.ts

@@ -1,5 +1,6 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@selesai/code";
+import { normalizePublicSubagentExecution } from "../extension/public-execution.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import {
 	SLASH_SUBAGENT_CANCEL_EVENT,
@@ -27,6 +28,8 @@ export interface SlashSubagentResponse {
 export interface SlashSubagentUpdate {
 	requestId: string;
 	progress?: Details["progress"];
+	workflow?: Details["workflow"];
+	chatProgress?: Details["chatProgress"];
 	currentTool?: string;
 	toolCount?: number;
 }
@@ -77,21 +80,22 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		if (!data || typeof data !== "object") return;
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
-		const { requestId, params } = request as SlashSubagentRequest;
-		if (params.tasks !== undefined || params.chain !== undefined || params.concurrency !== undefined || params.worktree !== undefined || params.chainDir !== undefined) {
-			const message = "Legacy slash-event chain and parallel inputs were removed; use workflowScript.";
+		const { requestId } = request as SlashSubagentRequest;
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
+		if (!normalized.ok) {
 			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
 				requestId,
 				result: {
-					content: [{ type: "text", text: message }],
+					content: [{ type: "text", text: normalized.error }],
 					isError: true,
-					details: { mode: "management", results: [] },
+					details: { mode: normalized.mode, results: [] },
 				},
 				isError: true,
-				errorText: message,
+				errorText: normalized.error,
 			} satisfies SlashSubagentResponse);
 			return;
 		}
+		const params = normalized.params;
 
 		const ctx = request.ctx ?? options.getContext();
 		if (!ctx) {
@@ -140,6 +144,8 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 					const payload: SlashSubagentUpdate = {
 						requestId,
 						progress,
+						workflow: update.details?.workflow,
+						chatProgress: update.details?.chatProgress,
 						currentTool: first?.currentTool,
 						toolCount: first?.toolCount,
 					};