@nghyane/arcane 0.1.13 → 0.1.15

package/src/modes/components/codemode-group.ts

@@ -1,369 +0,0 @@
-import type { AgentTool } from "@nghyane/arcane-agent";
-import type { Component, TUI } from "@nghyane/arcane-tui";
-import { Text } from "@nghyane/arcane-tui";
-import { getSymbolTheme, theme } from "../../modes/theme/theme";
-import { shortenPath } from "../../tools/render-utils";
-import { getTreeBranch, getTreeContinuePrefix } from "../../tui";
-import { ToolExecutionComponent, type ToolExecutionHandle, type ToolExecutionOptions } from "./tool-execution";
-
-/** Visible width of the tree prefix added to each sub-tool line. */
-const TREE_PREFIX_WIDTH = 6; // 3 leading spaces + branch/continue chars + trailing space
-
-type ReadEntry = {
-	path: string;
-	offset?: number;
-	limit?: number;
-	status: "pending" | "success" | "error";
-	text: Text;
-};
-
-type ToolHistoryEntry = { tool: string; args: string; status: "success" | "error" | "running" };
-
-const SUBAGENT_TOOLS = new Set(["explore", "oracle", "librarian", "code_review"]);
-
-const SUBAGENT_LABELS: Record<string, string> = {
-	explore: "Explore",
-	oracle: "Oracle",
-	librarian: "Librarian",
-	code_review: "Code Review",
-};
-
-class SubagentComponent implements Component, ToolExecutionHandle {
-	#label: string;
-	#description: string;
-	#status: "pending" | "success" | "error" = "pending";
-	#toolHistory: ToolHistoryEntry[] = [];
-	#dirty = true;
-	#cachedLines: string[] = [];
-	#cachedWidth = 0;
-
-	constructor(toolName: string, args: Record<string, unknown>) {
-		this.#label = SUBAGENT_LABELS[toolName] ?? toolName;
-		const raw = ((args.query ?? args.task ?? args.diff_description ?? "") as string).trim();
-		this.#description = raw;
-	}
-
-	// --- Component ---
-
-	render(width: number): string[] {
-		if (!this.#dirty && this.#cachedWidth === width) return this.#cachedLines;
-		this.#cachedWidth = width;
-		this.#dirty = false;
-
-		const lines: string[] = [];
-
-		// Header line: ✓ Explore  Find all code that references...
-		const icon = this.#statusIcon(this.#status);
-		const desc = this.#description ? `  ${theme.fg("dim", this.#description)}` : "";
-		lines.push(`${icon} ${theme.fg("toolTitle", theme.bold(this.#label))}${desc}`);
-
-		// Child tool history with inner tree branches
-		for (let i = 0; i < this.#toolHistory.length; i++) {
-			const entry = this.#toolHistory[i];
-			const isLast = i === this.#toolHistory.length - 1;
-			const branch = getTreeBranch(isLast, theme);
-			const childIcon = this.#statusIcon(entry.status);
-			const toolLabel = this.#childToolLabel(entry);
-			const line = `${theme.fg("dim", branch)} ${childIcon} ${toolLabel}`;
-			lines.push(line);
-		}
-
-		this.#cachedLines = lines;
-		return lines;
-	}
-
-	invalidate(): void {
-		this.#dirty = true;
-	}
-
-	// --- ToolExecutionHandle ---
-
-	updateArgs(): void {}
-
-	updateResult(result: any, isPartial?: boolean): void {
-		if (isPartial) {
-			const progress = result?.details?.progress as Array<{ toolHistory?: ToolHistoryEntry[] }> | undefined;
-			if (progress?.[0]?.toolHistory) {
-				this.#toolHistory = progress[0].toolHistory;
-				this.#dirty = true;
-			}
-			return;
-		}
-		this.#status = result?.isError ? "error" : "success";
-		// Final result may also carry toolHistory
-		const progress = result?.details?.progress as Array<{ toolHistory?: ToolHistoryEntry[] }> | undefined;
-		if (progress?.[0]?.toolHistory) {
-			this.#toolHistory = progress[0].toolHistory;
-		}
-		this.#dirty = true;
-	}
-
-	setArgsComplete(): void {}
-	setExpanded(): void {}
-
-	// --- Private ---
-
-	#statusIcon(status: "pending" | "success" | "error" | "running"): string {
-		switch (status) {
-			case "success":
-				return theme.fg("success", theme.status.success);
-			case "error":
-				return theme.fg("error", theme.status.error);
-			case "running":
-				return theme.fg("dim", theme.status.pending);
-			default:
-				return theme.fg("dim", theme.status.pending);
-		}
-	}
-
-	#childToolLabel(entry: ToolHistoryEntry): string {
-		const name = theme.fg("toolTitle", theme.bold(this.#prettyToolName(entry.tool)));
-		const args = entry.args ? `  ${theme.fg("dim", entry.args)}` : "";
-		return `${name}${args}`;
-	}
-
-	#prettyToolName(name: string): string {
-		// Capitalize first letter: grep → Grep, read → Read
-		return name.charAt(0).toUpperCase() + name.slice(1);
-	}
-}
-
-export class CodeModeGroupComponent implements Component, ToolExecutionHandle {
-	#header: Text;
-	#logsText: Text;
-	#orderedSubTools: Component[] = [];
-	#entries = new Map<string, { toolCallId: string; component: ToolExecutionComponent }>();
-	#readEntries = new Map<string, ReadEntry>();
-	#intent = "";
-	#expanded = false;
-	#logs: string[] = [];
-	#done = false;
-	#ui: TUI;
-	#spinnerFrames: string[];
-	#spinnerFrame = 0;
-	#spinnerInterval?: NodeJS.Timeout;
-
-	constructor(ui: TUI) {
-		this.#ui = ui;
-		this.#header = new Text("", 0, 0);
-		this.#logsText = new Text("", 0, 0);
-		this.#spinnerFrames = getSymbolTheme().spinnerFrames;
-		this.#startSpinner();
-		this.#updateHeader();
-	}
-
-	// --- Component ---
-
-	render(width: number): string[] {
-		const lines: string[] = [];
-
-		// Spacer
-		lines.push("");
-
-		// Header
-		lines.push(...this.#header.render(width));
-
-		// Sub-tools with tree connectors
-		const subToolWidth = Math.max(1, width - TREE_PREFIX_WIDTH);
-		for (let i = 0; i < this.#orderedSubTools.length; i++) {
-			const isLast = i === this.#orderedSubTools.length - 1;
-			const tool = this.#orderedSubTools[i];
-			const toolLines = tool.render(subToolWidth);
-
-			const branch = getTreeBranch(isLast, theme);
-			const cont = getTreeContinuePrefix(isLast, theme);
-			const branchPfx = `   ${theme.fg("dim", branch)} `;
-			const contPfx = `   ${theme.fg("dim", cont)}`;
-
-			let firstContent = true;
-			const contentLines: string[] = [];
-			for (const line of toolLines) {
-				// Skip leading empty lines (from Spacer(1) in ToolExecutionComponent)
-				if (firstContent && !line.trim()) continue;
-
-				if (firstContent) {
-					contentLines.push(`${branchPfx}${line}`);
-					firstContent = false;
-				} else {
-					contentLines.push(line.trim() ? `${contPfx}${line}` : "");
-				}
-			}
-			// Only emit if the sub-tool produced visible content
-			if (!firstContent) {
-				lines.push(...contentLines);
-			}
-		}
-
-		// Logs
-		lines.push(...this.#logsText.render(width));
-
-		return lines;
-	}
-
-	invalidate(): void {
-		this.#header.invalidate?.();
-		this.#logsText.invalidate?.();
-		for (const tool of this.#orderedSubTools) {
-			tool.invalidate?.();
-		}
-	}
-
-	// --- ToolExecutionHandle (no-ops on the group itself) ---
-
-	updateArgs(_args: any, _toolCallId?: string): void {}
-
-	updateResult(
-		_result: {
-			content: Array<{ type: string; text?: string; data?: string; mimeType?: string }>;
-			details?: any;
-			isError?: boolean;
-		},
-		_isPartial?: boolean,
-		_toolCallId?: string,
-	): void {}
-
-	setArgsComplete(_toolCallId?: string): void {}
-
-	setExpanded(expanded: boolean): void {
-		this.#expanded = expanded;
-		for (const entry of this.#entries.values()) {
-			entry.component.setExpanded(expanded);
-		}
-	}
-
-	// --- Sub-tool management ---
-
-	addSubTool(
-		toolCallId: string,
-		toolName: string,
-		args: any,
-		tool: AgentTool | undefined,
-		options: ToolExecutionOptions,
-		ui: TUI,
-		cwd: string,
-	): ToolExecutionHandle {
-		if (toolName === "read") {
-			return this.#addReadItem(toolCallId, args);
-		}
-		if (SUBAGENT_TOOLS.has(toolName)) {
-			const component = new SubagentComponent(toolName, args as Record<string, unknown>);
-			this.#orderedSubTools.push(component);
-			return component;
-		}
-
-		const component = new ToolExecutionComponent(toolName, args, options, tool, ui, cwd, { compact: true });
-		component.setExpanded(this.#expanded);
-		this.#entries.set(toolCallId, { toolCallId, component });
-		this.#orderedSubTools.push(component);
-		return component;
-	}
-
-	getSubTool(toolCallId: string): ToolExecutionHandle | undefined {
-		return this.#entries.get(toolCallId)?.component;
-	}
-
-	// --- Read items (flat, no sub-tree) ---
-
-	#addReadItem(toolCallId: string, args: any): ToolExecutionHandle {
-		const readArgs = args as { path?: string; file_path?: string; offset?: number; limit?: number };
-		const text = new Text("", 0, 0);
-		const entry: ReadEntry = {
-			path: readArgs.file_path || readArgs.path || "",
-			offset: readArgs.offset,
-			limit: readArgs.limit,
-			status: "pending",
-			text,
-		};
-		this.#readEntries.set(toolCallId, entry);
-		this.#orderedSubTools.push(text);
-		this.#updateReadDisplay(entry);
-
-		return {
-			updateArgs: (newArgs: any, _toolCallId?: string) => {
-				const a = newArgs as { path?: string; file_path?: string; offset?: number; limit?: number };
-				entry.path = a.file_path || a.path || entry.path;
-				entry.offset = a.offset ?? entry.offset;
-				entry.limit = a.limit ?? entry.limit;
-				this.#updateReadDisplay(entry);
-			},
-			updateResult: (result: any, isPartial?: boolean, _toolCallId?: string) => {
-				if (isPartial) return;
-				entry.status = result.isError ? "error" : "success";
-				this.#updateReadDisplay(entry);
-			},
-			setArgsComplete: () => {},
-			setExpanded: () => {},
-		};
-	}
-
-	#updateReadDisplay(entry: ReadEntry): void {
-		const statusIcon =
-			entry.status === "success"
-				? theme.fg("success", theme.status.success)
-				: entry.status === "error"
-					? theme.fg("error", theme.status.error)
-					: theme.fg("dim", theme.status.pending);
-		const filePath = shortenPath(entry.path);
-		let pathDisplay = filePath ? theme.fg("accent", filePath) : theme.fg("toolOutput", "…");
-		if (entry.offset !== undefined || entry.limit !== undefined) {
-			const startLine = entry.offset ?? 1;
-			const endLine = entry.limit !== undefined ? startLine + entry.limit - 1 : "";
-			pathDisplay += theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
-		}
-		entry.text.setText(`${statusIcon} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd());
-	}
-
-	// --- Public setters ---
-
-	setIntent(intent: string): void {
-		this.#intent = intent;
-		this.#updateHeader();
-	}
-
-	setLogs(logs: string[]): void {
-		this.#logs = logs;
-		this.#updateLogs();
-	}
-
-	setDone(): void {
-		this.#done = true;
-		this.#stopSpinner();
-		this.#updateHeader();
-	}
-
-	// --- Rendering ---
-
-	#updateHeader(): void {
-		const icon = this.#done
-			? theme.fg("success", theme.status.success)
-			: theme.fg("accent", this.#spinnerFrames[this.#spinnerFrame] ?? theme.format.bullet);
-		const intent = this.#intent || "Running";
-		this.#header.setText(` ${icon} ${theme.fg("muted", intent)}`);
-	}
-
-	#startSpinner(): void {
-		if (this.#spinnerInterval) return;
-		this.#spinnerInterval = setInterval(() => {
-			if (this.#done) return;
-			this.#spinnerFrame = (this.#spinnerFrame + 1) % this.#spinnerFrames.length;
-			this.#updateHeader();
-			this.#ui.requestRender();
-		}, 80);
-	}
-
-	#stopSpinner(): void {
-		if (this.#spinnerInterval) {
-			clearInterval(this.#spinnerInterval);
-			this.#spinnerInterval = undefined;
-		}
-	}
-
-	#updateLogs(): void {
-		if (this.#logs.length === 0) {
-			this.#logsText.setText("");
-			return;
-		}
-		const lines = this.#logs.map(log => `   ${theme.tree.vertical} ${theme.fg("dim", log)}`);
-		this.#logsText.setText(lines.join("\n"));
-	}
-}

package/src/modes/components/read-tool-group.ts

@@ -1,119 +0,0 @@
-import { Container, Text } from "@nghyane/arcane-tui";
-import { theme } from "../../modes/theme/theme";
-import { shortenPath } from "../../tools/render-utils";
-import type { ToolExecutionHandle } from "./tool-execution";
-
-type ReadRenderArgs = {
-	path?: string;
-	file_path?: string;
-	offset?: number;
-	limit?: number;
-};
-
-type ReadEntry = {
-	toolCallId: string;
-	path: string;
-	offset?: number;
-	limit?: number;
-	status: "pending" | "success" | "error";
-};
-
-export class ReadToolGroupComponent extends Container implements ToolExecutionHandle {
-	#entries = new Map<string, ReadEntry>();
-	#text: Text;
-
-	constructor() {
-		super();
-		this.#text = new Text("", 0, 0);
-		this.addChild(this.#text);
-		this.#updateDisplay();
-	}
-
-	updateArgs(args: ReadRenderArgs, toolCallId?: string): void {
-		if (!toolCallId) return;
-		const rawPath = args.file_path || args.path || "";
-		const entry: ReadEntry = this.#entries.get(toolCallId) ?? {
-			toolCallId,
-			path: rawPath,
-			offset: args.offset,
-			limit: args.limit,
-			status: "pending",
-		};
-		entry.path = rawPath;
-		entry.offset = args.offset;
-		entry.limit = args.limit;
-		this.#entries.set(toolCallId, entry);
-		this.#updateDisplay();
-	}
-
-	updateResult(
-		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
-		isPartial = false,
-		toolCallId?: string,
-	): void {
-		if (!toolCallId) return;
-		const entry = this.#entries.get(toolCallId);
-		if (!entry) return;
-		if (isPartial) return;
-		entry.status = result.isError ? "error" : "success";
-		this.#updateDisplay();
-	}
-
-	setArgsComplete(_toolCallId?: string): void {
-		this.#updateDisplay();
-	}
-
-	setExpanded(_expanded: boolean): void {
-		this.#updateDisplay();
-	}
-
-	#updateDisplay(): void {
-		const entries = [...this.#entries.values()];
-
-		if (entries.length === 0) {
-			this.#text.setText(` ${theme.format.bullet} ${theme.fg("toolTitle", theme.bold("Read"))}`);
-			return;
-		}
-
-		if (entries.length === 1) {
-			const entry = entries[0];
-			const statusSymbol = this.#formatStatus(entry.status);
-			const pathDisplay = this.#formatPath(entry);
-			this.#text.setText(` ${statusSymbol} ${theme.fg("toolTitle", theme.bold("Read"))} ${pathDisplay}`.trimEnd());
-			return;
-		}
-
-		const header = `${theme.fg("toolTitle", theme.bold("Read"))}${theme.fg("dim", ` (${entries.length})`)}`;
-		const lines = [` ${theme.format.bullet} ${header}`];
-		const total = entries.length;
-		for (const [index, entry] of entries.entries()) {
-			const connector = index === total - 1 ? theme.tree.last : theme.tree.branch;
-			const statusSymbol = this.#formatStatus(entry.status);
-			const pathDisplay = this.#formatPath(entry);
-			lines.push(`   ${theme.fg("dim", connector)} ${statusSymbol} ${pathDisplay}`.trimEnd());
-		}
-
-		this.#text.setText(lines.join("\n"));
-	}
-
-	#formatPath(entry: ReadEntry): string {
-		const filePath = shortenPath(entry.path);
-		let pathDisplay = filePath ? theme.fg("accent", filePath) : theme.fg("toolOutput", "…");
-		if (entry.offset !== undefined || entry.limit !== undefined) {
-			const startLine = entry.offset ?? 1;
-			const endLine = entry.limit !== undefined ? startLine + entry.limit - 1 : "";
-			pathDisplay += theme.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
-		}
-		return pathDisplay;
-	}
-
-	#formatStatus(status: ReadEntry["status"]): string {
-		if (status === "success") {
-			return theme.fg("success", theme.status.success);
-		}
-		if (status === "error") {
-			return theme.fg("error", theme.status.error);
-		}
-		return theme.fg("dim", theme.status.pending);
-	}
-}

package/src/modes/components/visual-truncate.ts

@@ -1,63 +0,0 @@
-/**
- * Shared utility for truncating text to visual lines (accounting for line wrapping).
- * Used by both tool-execution.ts and bash-execution.ts for consistent behavior.
- */
-import { Text } from "@nghyane/arcane-tui";
-
-export interface VisualTruncateResult {
-	/** The visual lines to display */
-	visualLines: string[];
-	/** Number of visual lines that were skipped (hidden) */
-	skippedCount: number;
-}
-
-const textCache = new Map<number, Text>();
-
-function getCachedText(paddingX: number): Text {
-	let text = textCache.get(paddingX);
-	if (!text) {
-		text = new Text("", paddingX, 0);
-		textCache.set(paddingX, text);
-	}
-	return text;
-}
-
-/**
- * Truncate text to a maximum number of visual lines (from the end).
- * This accounts for line wrapping based on terminal width.
- *
- * @param text - The text content (may contain newlines)
- * @param maxVisualLines - Maximum number of visual lines to show
- * @param width - Terminal/render width
- * @param paddingX - Horizontal padding for Text component (default 0).
- *                   Use 0 when result will be placed in a Box (Box adds its own padding).
- *                   Use 1 when result will be placed in a plain Container.
- * @returns The truncated visual lines and count of skipped lines
- */
-export function truncateToVisualLines(
-	text: string,
-	maxVisualLines: number,
-	width: number,
-	paddingX: number = 0,
-): VisualTruncateResult {
-	if (!text) {
-		return { visualLines: [], skippedCount: 0 };
-	}
-
-	// Create a temporary Text component to render and get visual lines
-	const tempText = getCachedText(paddingX);
-	if (tempText.getText() !== text) {
-		tempText.setText(text);
-	}
-	const allVisualLines = tempText.render(width);
-
-	if (allVisualLines.length <= maxVisualLines) {
-		return { visualLines: allVisualLines, skippedCount: 0 };
-	}
-
-	// Take the last N visual lines
-	const truncatedLines = allVisualLines.slice(-maxVisualLines);
-	const skippedCount = allVisualLines.length - maxVisualLines;
-
-	return { visualLines: truncatedLines, skippedCount };
-}

package/src/prompts/system/subagent-user-prompt.md

@@ -1,8 +0,0 @@
-{{#if context}}
-<swarm_context>{{context}}</swarm_context>
-
-# Your Assignment
-{{assignment}}
-{{else}}
-{{assignment}}
-{{/if}}

package/src/prompts/tools/ask.md

@@ -1,44 +0,0 @@
-# Ask
-
-Ask user when you need clarification or input during task execution.
-
-<conditions>
-- Multiple approaches exist with significantly different tradeoffs user should weigh
-</conditions>
-
-<instruction>
-- Use `recommended: <index>` to mark default (0-indexed); " (Recommended)" added automatically
-- Use `questions` for multiple related questions instead of asking one at a time
-- Set `multi: true` on question to allow multiple selections
-</instruction>
-
-<output>
-Returns selected option(s) as text. For multi-part questions, returns map of question IDs to selected values.
-</output>
-
-<caution>
-- Provide 2-5 concise, distinct options
-</caution>
-
-<critical>
-**Default to action. Do NOT ask unless you are genuinely blocked and user preference is required to avoid a wrong outcome.**
-1. **Resolve ambiguity yourself** using repo conventions, existing patterns, and reasonable defaults.
-2. **Exhaust existing sources** (code, configs, docs, history) before asking anything.
-3. **If multiple choices are acceptable**, pick the most conservative/standard option and proceed; state the choice.
-4. **Only ask when options have materially different tradeoffs and the user must decide.**
-**Do NOT include "Other" option in your options array.** UI automatically adds "Other (type your own)" to every question; adding your own creates duplicates.
-</critical>
-
-<example name="single">
-question: "Which authentication method should this API use?"
-options: [{"label": "JWT"}, {"label": "OAuth2"}, {"label": "Session cookies"}]
-recommended: 0
-</example>
-
-<example name="multi-part">
-questions: [
-  {"id": "auth", "question": "Which auth method?", "options": [{"label": "JWT"}, {"label": "OAuth2"}], "recommended": 0},
-  {"id": "cache", "question": "Enable caching?", "options": [{"label": "Yes"}, {"label": "No"}]},
-  {"id": "features", "question": "Which features to include?", "options": [{"label": "Logging"}, {"label": "Metrics"}, {"label": "Tracing"}], "multi": true}
-]
-</example>

package/src/prompts/tools/bash.md

@@ -1,24 +0,0 @@
-# Bash
-
-Executes bash command in shell session for terminal operations like git, bun, cargo, python.
-
-<instruction>
-- Use `cwd` parameter to set working directory instead of `cd dir && ...`
-- Use `;` only when later commands should run regardless of earlier failures
-- `skill://` URIs are auto-resolved to filesystem paths before execution
-	- `python skill://my-skill/scripts/init.py` runs the script from the skill directory
-	- `skill://<name>/<relative-path>` resolves within the skill's base directory
-- `agent://`, `artifact://`, `plan://`, `memory://`, `rule://`, and `docs://` URIs are also auto-resolved to filesystem paths before execution
-</instruction>
-
-<output>
-Returns the output, and an exit code from command execution.
-- If output truncated, full output stored under $ARTIFACTS and referenced as `artifact://<id>` in metadata
-- Exit codes shown on non-zero exit
-</output>
-
-<critical>
-- Do NOT use Bash for these operations like read, grep, find, edit, write, where specialized tools exist.
-- Do NOT use `2>&1` pattern, stdout and stderr are already merged.
-- Do NOT use `| head -n 50` or `| tail -n 100` pattern, use `head` and `tail` parameters instead.
-</critical>

package/src/prompts/tools/browser.md

@@ -1,33 +0,0 @@
-# Browser
-
-Use this tool to navigate, click, type, scroll, drag, query DOM content, and capture screenshots.
-
-<instruction>
-- Use `action: "open"` to start a new headless browser session (or implicitly launch on first action)
-- Use `action: "goto"` with `url` to navigate
-- Use `action: "observe"` to capture a numbered accessibility snapshot with URL/title/viewport/scroll info
-	- Prefer `click_id`, `type_id`, or `fill_id` actions using the returned `element_id` values
-	- Optional flags: `include_all` to include non-interactive nodes, `viewport_only` to limit to visible elements
-- Use `action: "click"`, `"type"`, `"fill"`, `"press"`, `"scroll"`, or `"drag"` for selector-based interactions
-	- Prefer ARIA or text selectors (e.g. `p-aria/[name="Sign in"]`, `p-text/Continue`) over brittle CSS
-- Use `action: "click_id"`, `"type_id"`, or `"fill_id"` to interact with observed elements without selectors
-- Use `action: "wait_for_selector"` before interacting when the page is dynamic
-- Use `action: "evaluate"` with `script` to run a JavaScript expression in the page context
-- Use `action: "get_text"`, `"get_html"`, or `"get_attribute"` for DOM queries
-	- For batch queries, pass `args: [{ selector, attribute? }]` to get an array of results (attribute required for `get_attribute`)
-- Use `action: "extract_readable"` to return reader-mode content (title/byline/excerpt/text or markdown)
-	- Set `format` to `"markdown"` (default) or `"text"`
-- Use `action: "screenshot"` to capture images (optionally with `selector` to capture a single element)
-- Use `action: "close"` to release the browser when done
-</instruction>
-
-<critical>
-**Default to `observe`, not `screenshot`.**
-- `observe` is cheaper, faster, and returns structured data — use it to understand page state, find elements, and plan interactions.
-- Only use `screenshot` when visual appearance matters (verifying layout, debugging CSS, capturing a visual artifact for the user).
-- Never screenshot just to "see what's on the page" — `observe` gives you that with element IDs you can act on immediately.
-</critical>
-
-<output>
-Returns text output for navigation and DOM queries, and image output for screenshots. Screenshots can optionally be saved to disk via the `path` parameter.
-</output>

package/src/prompts/tools/calculator.md

@@ -1,12 +0,0 @@
-# Calculator
-
-Basic calculations.
-
-<instruction>
-- Supports +, -, *, /, %, ** and parentheses
-- Supports decimal, hex (0x), binary (0b), and octal (0o) literals
-</instruction>
-
-<output>
-Returns each calculation result with its prefix and suffix applied.
-</output>