@oh-my-pi/pi-coding-agent 14.1.0 → 14.1.2

package/src/tools/bash.ts

@@ -73,6 +73,7 @@ export interface BashToolInput {
 
 export interface BashToolDetails {
 	meta?: OutputMeta;
+	timeoutSeconds?: number;
 	async?: {
 		state: "running" | "completed" | "failed";
 		jobId: string;
@@ -290,14 +291,20 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		tailLines?: number,
 	): AgentToolResult<BashToolDetails> {
 		const outputText = this.#formatResultOutput(result, headLines, tailLines);
-		const details: BashToolDetails = {};
+		const details: BashToolDetails = { timeoutSeconds: timeoutSec };
 		const resultBuilder = toolResult(details).text(outputText).truncationFromSummary(result, { direction: "tail" });
 		this.#buildResultText(result, timeoutSec, outputText);
 		return resultBuilder.done();
 	}
 
-	#buildBackgroundStartResult(jobId: string, label: string, previewText: string): AgentToolResult<BashToolDetails> {
+	#buildBackgroundStartResult(
+		jobId: string,
+		label: string,
+		previewText: string,
+		timeoutSec: number,
+	): AgentToolResult<BashToolDetails> {
 		const details: BashToolDetails = {
+			timeoutSeconds: timeoutSec,
 			async: { state: "running", jobId, type: "bash" },
 		};
 		const lines: string[] = [];
@@ -307,7 +314,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 		lines.push(`Background job ${jobId} started: ${label}`);
 		lines.push("Result will be delivered automatically when complete.");
-		lines.push(`Use \`await\`, \`read jobs://${jobId}\`, or \`cancel_job\` if needed.`);
+		lines.push(`Use \`poll\`, \`read jobs://${jobId}\`, or \`cancel_job\` if needed.`);
 		return {
 			content: [{ type: "text", text: lines.join("\n") }],
 			details,
@@ -430,6 +437,12 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 		}
 	}
 
+	#resolveAutoBackgroundWaitMs(timeoutMs: number): number {
+		if (this.#autoBackgroundThresholdMs <= 0) return 0;
+		const timeoutBufferMs = 1_000;
+		return Math.max(0, Math.min(this.#autoBackgroundThresholdMs, timeoutMs - timeoutBufferMs));
+	}
+
 	async execute(
 		_toolCallId: string,
 		{
@@ -536,10 +549,12 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				onUpdate,
 				startBackgrounded: true,
 			});
-			return this.#buildBackgroundStartResult(job.jobId, job.label, "");
+			return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
 		}
 
 		if (this.#autoBackgroundEnabled && !pty && this.session.asyncJobManager) {
+			const autoBackgroundWaitMs = this.#resolveAutoBackgroundWaitMs(timeoutMs);
+			const startBackgrounded = autoBackgroundWaitMs === 0;
 			const job = this.#startManagedBashJob({
 				command,
 				commandCwd,
@@ -549,9 +564,12 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				tailLines,
 				resolvedEnv,
 				onUpdate,
-				startBackgrounded: false,
+				startBackgrounded,
 			});
-			const waitResult = await this.#waitForManagedBashJob(job, this.#autoBackgroundThresholdMs, signal);
+			if (startBackgrounded) {
+				return this.#buildBackgroundStartResult(job.jobId, job.label, "", timeoutSec);
+			}
+			const waitResult = await this.#waitForManagedBashJob(job, autoBackgroundWaitMs, signal);
 			if (waitResult.kind === "completed") {
 				this.session.asyncJobManager.acknowledgeDeliveries([job.jobId]);
 				return waitResult.result;
@@ -566,7 +584,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 				throw new ToolAbortError(job.getLatestText() || "Command aborted");
 			}
 			job.setBackgrounded(true);
-			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText());
+			return this.#buildBackgroundStartResult(job.jobId, job.label, job.getLatestText(), timeoutSec);
 		}
 
 		// Track output for streaming updates (tail only)
@@ -689,7 +707,7 @@ export const bashToolRenderer = {
 				const showingFullOutput = expanded && renderContext?.isFullOutput === true;
 
 				// Build truncation warning
-				const timeoutSeconds = renderContext?.timeout;
+				const timeoutSeconds = details?.timeoutSeconds ?? renderContext?.timeout;
 				const timeoutLine =
 					typeof timeoutSeconds === "number"
 						? uiTheme.fg(

package/src/tools/find.ts

@@ -244,17 +244,20 @@ export class FindTool implements AgentTool<typeof findSchema, FindToolDetails> {
 							maxResults: effectiveLimit,
 							sortByMtime: true,
 							gitignore: useGitignore,
+							signal: combinedSignal,
 						},
 						onMatch,
-						this.session.searchDb,
 					),
 				);
 
 			try {
 				let result = await doGlob(true);
-				if (result.matches.length === 0) {
+				if (result.matches.length === 0 && !timeoutSignal.aborted) {
 					result = await doGlob(false);
 				}
+				// Sort by mtime descending (most recent first) in JS instead of native.
+				// This allows native glob to early-terminate at maxResults.
+				result.matches.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
 				matches = result.matches;
 			} catch (error) {
 				if (error instanceof Error && error.name === "AbortError") {

package/src/tools/grep.ts

@@ -7,7 +7,7 @@ import { Text } from "@oh-my-pi/pi-tui";
 import { prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { computeLineHash } from "../edit/line-hash";
-import { formatChunkedGrepLine } from "../edit/modes/chunk";
+import { type ChunkedGrepMatch, describeChunkedGrepMatch } from "../edit/modes/chunk";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import { getLanguageFromPath, type Theme } from "../modes/theme/theme";
 import grepDescription from "../prompts/tools/grep.md" with { type: "text" };
@@ -162,7 +162,8 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				const stat = await Bun.file(searchPath).stat();
 				isDirectory = stat.isDirectory();
 			} catch {
-				throw new ToolError(`Path not found: ${scopePath}`);
+				const hint = scopePath.includes(",") ? ` (comma-separated paths must each exist relative to cwd)` : "";
+				throw new ToolError(`Path not found: ${scopePath}${hint}`);
 			}
 
 			const effectiveOutputMode = GrepOutputMode.Content;
@@ -191,7 +192,6 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						mode: effectiveOutputMode,
 					},
 					undefined,
-					this.session.searchDb,
 				);
 			} catch (err) {
 				if (err instanceof Error && err.message.startsWith("regex parse error")) {
@@ -274,13 +274,11 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 				matchesByFile.get(relativePath)!.push(match);
 			}
 			if (chunkMode) {
-				const annotatedLines = await Promise.all(
+				const annotatedMatches = await Promise.all(
 					selectedMatches.map(match => {
 						const relativePath = match.path.startsWith("/") ? match.path.slice(1) : match.path;
 						const absoluteFilePath = isDirectory ? path.join(searchPath, relativePath) : searchPath;
-						const displayPath = formatPath(match.path);
-						fileMatchCounts.set(displayPath, (fileMatchCounts.get(displayPath) ?? 0) + 1);
-						return formatChunkedGrepLine({
+						return describeChunkedGrepMatch({
 							filePath: absoluteFilePath,
 							lineNumber: match.lineNumber,
 							line: match.line,
@@ -289,7 +287,78 @@ export class GrepTool implements AgentTool<typeof grepSchema, GrepToolDetails> {
 						});
 					}),
 				);
-				const rawOutput = annotatedLines.join("\n");
+				const chunkMatchesByFile = new Map<string, ChunkedGrepMatch[]>();
+				for (const match of annotatedMatches) {
+					recordFile(match.displayPath);
+					if (!chunkMatchesByFile.has(match.displayPath)) {
+						chunkMatchesByFile.set(match.displayPath, []);
+					}
+					chunkMatchesByFile.get(match.displayPath)!.push(match);
+				}
+				const renderChunkedMatchesForFile = (relativePath: string) => {
+					const fileMatches = chunkMatchesByFile.get(relativePath) ?? [];
+					if (fileMatches.length === 0) {
+						return;
+					}
+					const lineWidth = fileMatches[0]?.fileLineCount.toString().length ?? 1;
+					const matchesByChunk = new Map<string, ChunkedGrepMatch[]>();
+					for (const match of fileMatches) {
+						const chunkKey = match.chunkPath ?? "";
+						if (!matchesByChunk.has(chunkKey)) {
+							matchesByChunk.set(chunkKey, []);
+						}
+						matchesByChunk.get(chunkKey)!.push(match);
+					}
+					for (const [chunkPath, chunkMatches] of matchesByChunk) {
+						if (chunkPath) {
+							const chunkChecksum = chunkMatches[0]?.chunkChecksum;
+							const dashes = "-".repeat(chunkPath.split(".").length - 1);
+							const anchor = chunkChecksum
+								? `${dashes}@${chunkPath}#${chunkChecksum}`
+								: `${dashes}@${chunkPath}`;
+							outputLines.push(anchor);
+						}
+						for (const match of chunkMatches) {
+							outputLines.push(`    ${match.lineNumber.toString().padStart(lineWidth, " ")} |${match.line}`);
+							fileMatchCounts.set(relativePath, (fileMatchCounts.get(relativePath) ?? 0) + 1);
+						}
+					}
+				};
+				if (isDirectory) {
+					const filesByDirectory = new Map<string, string[]>();
+					for (const relativePath of fileList) {
+						const directory = path.dirname(relativePath).replace(/\\/g, "/");
+						if (!filesByDirectory.has(directory)) {
+							filesByDirectory.set(directory, []);
+						}
+						filesByDirectory.get(directory)!.push(relativePath);
+					}
+					for (const [directory, directoryFiles] of filesByDirectory) {
+						if (directory === ".") {
+							for (const relativePath of directoryFiles) {
+								if (outputLines.length > 0) {
+									outputLines.push("");
+								}
+								outputLines.push(`# ${path.basename(relativePath)}`);
+								renderChunkedMatchesForFile(relativePath);
+							}
+							continue;
+						}
+						if (outputLines.length > 0) {
+							outputLines.push("");
+						}
+						outputLines.push(`# ${directory}`);
+						for (const relativePath of directoryFiles) {
+							outputLines.push(`## └─ ${path.basename(relativePath)}`);
+							renderChunkedMatchesForFile(relativePath);
+						}
+					}
+				} else {
+					for (const relativePath of fileList) {
+						renderChunkedMatchesForFile(relativePath);
+					}
+				}
+				const rawOutput = outputLines.join("\n");
 				const truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER });
 				const truncated = Boolean(matchLimitReached || result.limitReached || truncation.truncated);
 				const details: GrepToolDetails = {

package/src/tools/index.ts

@@ -1,6 +1,5 @@
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { ToolChoice } from "@oh-my-pi/pi-ai";
-import type { SearchDb } from "@oh-my-pi/pi-natives";
 import { $env, $flag, isBunTestRuntime, logger } from "@oh-my-pi/pi-utils";
 import type { AsyncJobManager } from "../async";
 import type { PromptTemplate } from "../config/prompt-templates";
@@ -8,7 +7,7 @@ import type { Settings } from "../config/settings";
 import { EditTool } from "../edit";
 import type { Skill } from "../extensibility/skills";
 import type { InternalUrlRouter } from "../internal-urls";
-import { getPreludeDocs, warmPythonEnvironment } from "../ipy/executor";
+import { getPreludeDocs, resetPreludeDocsCache, warmPythonEnvironment } from "../ipy/executor";
 import { checkPythonKernelAvailability } from "../ipy/kernel";
 import { LspTool } from "../lsp";
 import type { DiscoverableMCPSearchIndex, DiscoverableMCPTool } from "../mcp/discoverable-tool-metadata";
@@ -22,10 +21,8 @@ import { SearchTool } from "../web/search";
 import { AskTool } from "./ask";
 import { AstEditTool } from "./ast-edit";
 import { AstGrepTool } from "./ast-grep";
-import { AwaitTool } from "./await-tool";
 import { BashTool } from "./bash";
 import { BrowserTool } from "./browser";
-
 import { CalculatorTool } from "./calculator";
 import { CancelJobTool } from "./cancel-job";
 import { type CheckpointState, CheckpointTool, RewindTool } from "./checkpoint";
@@ -47,6 +44,7 @@ import { GrepTool } from "./grep";
 import { InspectImageTool } from "./inspect-image";
 import { NotebookTool } from "./notebook";
 import { wrapToolWithMetaNotice } from "./output-meta";
+import { PollTool } from "./poll-tool";
 import { PythonTool } from "./python";
 import { ReadTool } from "./read";
 import { RenderMermaidTool } from "./render-mermaid";
@@ -71,7 +69,6 @@ export * from "../web/search";
 export * from "./ask";
 export * from "./ast-edit";
 export * from "./ast-grep";
-export * from "./await-tool";
 export * from "./bash";
 export * from "./browser";
 export * from "./calculator";
@@ -85,6 +82,7 @@ export * from "./gh";
 export * from "./grep";
 export * from "./inspect-image";
 export * from "./notebook";
+export * from "./poll-tool";
 export * from "./python";
 export * from "./read";
 export * from "./render-mermaid";
@@ -95,6 +93,7 @@ export * from "./search-tool-bm25";
 export * from "./ssh";
 export * from "./submit-result";
 export * from "./todo-write";
+export * from "./vim";
 export * from "./write";
 
 /** Tool type (AgentTool from pi-ai) */
@@ -116,6 +115,8 @@ export interface ToolSession {
 	hasUI: boolean;
 	/** Skip Python kernel availability check and warmup */
 	skipPythonPreflight?: boolean;
+	/** Force Python prelude warmup even when test env would normally skip it */
+	forcePythonWarmup?: boolean;
 	/** Pre-loaded context files (AGENTS.md, etc) */
 	contextFiles?: ContextFileEntry[];
 	/** Pre-loaded skills */
@@ -124,7 +125,7 @@ export interface ToolSession {
 	promptTemplates?: PromptTemplate[];
 	/** Whether LSP integrations are enabled */
 	enableLsp?: boolean;
-	/** Whether the edit tool is available in this session (controls hashline output) */
+	/** Whether an edit-capable tool is available in this session (controls hashline output) */
 	hasEditTool?: boolean;
 	/** Event bus for tool/extension communication */
 	eventBus?: EventBus;
@@ -136,6 +137,12 @@ export interface ToolSession {
 	taskDepth?: number;
 	/** Get session file */
 	getSessionFile: () => string | null;
+	/** Get Python kernel owner ID for session-scoped retained-kernel cleanup */
+	getPythonKernelOwnerId?: () => string | null;
+	/** Reject new Python work once session disposal has started. */
+	assertPythonExecutionAllowed?: () => void;
+	/** Track tool-owned Python work so session disposal can await/abort it like direct session Python runs. */
+	trackPythonExecution?<T>(execution: Promise<T>, abortController: AbortController): Promise<T>;
 	/** Get session ID */
 	getSessionId?: () => string | null;
 	/** Get artifacts directory for artifact:// URLs */
@@ -162,8 +169,6 @@ export interface ToolSession {
 	asyncJobManager?: AsyncJobManager;
 	/** Settings instance for passing to subagents */
 	settings: Settings;
-	/** Shared native search DB for grep/glob/fuzzyFind-backed workflows. */
-	searchDb?: SearchDb;
 	/** Plan mode state (if active) */
 	getPlanModeState?: () => PlanModeState | undefined;
 	/** Get compact conversation context for subagents (excludes tool results, system prompts) */
@@ -232,7 +237,7 @@ export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	rewind: RewindTool.createIf,
 	task: TaskTool.create,
 	cancel_job: CancelJobTool.createIf,
-	await: AwaitTool.createIf,
+	poll: PollTool.createIf,
 	todo_write: s => new TodoWriteTool(s),
 	web_search: s => new SearchTool(s),
 	search_tool_bm25: SearchToolBm25Tool.createIf,
@@ -297,7 +302,11 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 		!skipPythonPreflight &&
 		pythonMode !== "bash-only" &&
 		(requestedTools === undefined || requestedTools.includes("python"));
-	const skipPythonWarm = isBunTestRuntime() || $flag("PI_PYTHON_SKIP_CHECK");
+	const isTestEnv = isBunTestRuntime();
+	const forcePythonWarmup = session.forcePythonWarmup === true;
+	const skipPythonWarm = (isTestEnv && !forcePythonWarmup) || $flag("PI_PYTHON_SKIP_CHECK");
+	const cachedPreludeDocs = getPreludeDocs();
+	const shouldWarmPython = !skipPythonWarm && (forcePythonWarmup || cachedPreludeDocs.length === 0);
 	if (shouldCheckPython) {
 		const availability = await logger.time("createTools:pythonCheck", checkPythonKernelAvailability, session.cwd);
 		pythonAvailable = availability.ok;
@@ -305,18 +314,38 @@ export async function createTools(session: ToolSession, toolNames?: string[]): P
 			logger.warn("Python kernel unavailable, falling back to bash", {
 				reason: availability.reason,
 			});
-		} else if (!skipPythonWarm && getPreludeDocs().length === 0) {
+		} else if (shouldWarmPython) {
 			const sessionFile = session.getSessionFile?.() ?? undefined;
+			const kernelOwnerId = session.getPythonKernelOwnerId?.() ?? undefined;
 			const warmSessionId = sessionFile ? `session:${sessionFile}:cwd:${session.cwd}` : `cwd:${session.cwd}`;
+			const warmupAbortController = new AbortController();
 			try {
-				await logger.time(
-					"createTools:warmPython",
-					warmPythonEnvironment,
-					session.cwd,
-					warmSessionId,
-					session.settings.get("python.sharedGateway"),
-					sessionFile,
-				);
+				session.assertPythonExecutionAllowed?.();
+				if (forcePythonWarmup && cachedPreludeDocs.length > 0) {
+					resetPreludeDocsCache();
+				}
+				const warmupExecution = session.trackPythonExecution
+					? logger.time(
+							"createTools:warmPython",
+							warmPythonEnvironment,
+							session.cwd,
+							warmSessionId,
+							session.settings.get("python.sharedGateway"),
+							sessionFile,
+							kernelOwnerId,
+							warmupAbortController.signal,
+						)
+					: logger.time(
+							"createTools:warmPython",
+							warmPythonEnvironment,
+							session.cwd,
+							warmSessionId,
+							session.settings.get("python.sharedGateway"),
+							sessionFile,
+							kernelOwnerId,
+						);
+				await (session.trackPythonExecution?.(warmupExecution, warmupAbortController) ?? warmupExecution);
+				session.assertPythonExecutionAllowed?.();
 			} catch (err) {
 				logger.warn("Failed to warm Python environment", {
 					error: err instanceof Error ? err.message : String(err),

package/src/tools/{await-tool.ts → poll-tool.ts}

@@ -2,10 +2,10 @@ import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallb
 import { prompt } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import { isBackgroundJobSupportEnabled } from "../async";
-import awaitDescription from "../prompts/tools/await.md" with { type: "text" };
+import pollDescription from "../prompts/tools/poll.md" with { type: "text" };
 import type { ToolSession } from "./index";
 
-const awaitSchema = Type.Object({
+const pollSchema = Type.Object({
 	jobs: Type.Optional(
 		Type.Array(Type.String(), {
 			description: "Specific job IDs to wait for. If omitted, waits for any running job.",
@@ -13,9 +13,9 @@ const awaitSchema = Type.Object({
 	),
 });
 
-type AwaitParams = Static<typeof awaitSchema>;
+type PollParams = Static<typeof pollSchema>;
 
-interface AwaitResult {
+interface PollResult {
 	id: string;
 	type: "bash" | "task";
 	status: "running" | "completed" | "failed" | "cancelled";
@@ -25,33 +25,33 @@ interface AwaitResult {
 	errorText?: string;
 }
 
-export interface AwaitToolDetails {
-	jobs: AwaitResult[];
+export interface PollToolDetails {
+	jobs: PollResult[];
 }
 
-export class AwaitTool implements AgentTool<typeof awaitSchema, AwaitToolDetails> {
-	readonly name = "await";
-	readonly label = "Await";
+export class PollTool implements AgentTool<typeof pollSchema, PollToolDetails> {
+	readonly name = "poll";
+	readonly label = "Poll";
 	readonly description: string;
-	readonly parameters = awaitSchema;
+	readonly parameters = pollSchema;
 	readonly strict = true;
 
 	constructor(private readonly session: ToolSession) {
-		this.description = prompt.render(awaitDescription);
+		this.description = prompt.render(pollDescription);
 	}
 
-	static createIf(session: ToolSession): AwaitTool | null {
+	static createIf(session: ToolSession): PollTool | null {
 		if (!isBackgroundJobSupportEnabled(session.settings)) return null;
-		return new AwaitTool(session);
+		return new PollTool(session);
 	}
 
 	async execute(
 		_toolCallId: string,
-		params: AwaitParams,
+		params: PollParams,
 		signal?: AbortSignal,
-		_onUpdate?: AgentToolUpdateCallback<AwaitToolDetails>,
+		_onUpdate?: AgentToolUpdateCallback<PollToolDetails>,
 		_context?: AgentToolContext,
-	): Promise<AgentToolResult<AwaitToolDetails>> {
+	): Promise<AgentToolResult<PollToolDetails>> {
 		const manager = this.session.asyncJobManager;
 		if (!manager) {
 			return {
@@ -85,19 +85,25 @@ export class AwaitTool implements AgentTool<typeof awaitSchema, AwaitToolDetails
 
 		// Block until at least one running job finishes or the call is aborted
 		const racePromises: Promise<unknown>[] = runningJobs.map(j => j.promise);
-
-		if (signal) {
-			const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
-			const onAbort = () => abortResolve();
-			signal.addEventListener("abort", onAbort, { once: true });
-			racePromises.push(abortPromise);
-			try {
+		const watchedJobIds = runningJobs.map(job => job.id);
+		manager.watchJobs(watchedJobIds);
+
+		try {
+			if (signal) {
+				const { promise: abortPromise, resolve: abortResolve } = Promise.withResolvers<void>();
+				const onAbort = () => abortResolve();
+				signal.addEventListener("abort", onAbort, { once: true });
+				racePromises.push(abortPromise);
+				try {
+					await Promise.race(racePromises);
+				} finally {
+					signal.removeEventListener("abort", onAbort);
+				}
+			} else {
 				await Promise.race(racePromises);
-			} finally {
-				signal.removeEventListener("abort", onAbort);
 			}
-		} else {
-			await Promise.race(racePromises);
+		} finally {
+			manager.unwatchJobs(watchedJobIds);
 		}
 
 		if (signal?.aborted) {
@@ -118,12 +124,12 @@ export class AwaitTool implements AgentTool<typeof awaitSchema, AwaitToolDetails
 			resultText?: string;
 			errorText?: string;
 		}[],
-	): AgentToolResult<AwaitToolDetails> {
+	): AgentToolResult<PollToolDetails> {
 		const now = Date.now();
-		const jobResults: AwaitResult[] = jobs.map(j => ({
+		const jobResults: PollResult[] = jobs.map(j => ({
 			id: j.id,
 			type: j.type,
-			status: j.status as AwaitResult["status"],
+			status: j.status as PollResult["status"],
 			label: j.label,
 			durationMs: Math.max(0, now - j.startTime),
 			...(j.resultText ? { resultText: j.resultText } : {}),