@supatest/cli 0.0.3 → 0.0.5

package/dist/agent-runner.js

@@ -1,589 +0,0 @@
-import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
-import { query } from "@anthropic-ai/claude-agent-sdk";
-import chalk from "chalk";
-import ora from "ora";
-import { config as envConfig } from "./config";
-import { ApiClient } from "./services/api-client";
-import { EventStreamer } from "./services/event-streamer";
-import { logger } from "./utils/logger";
-import { generateSummary } from "./utils/summary";
-const CLI_VERSION = "0.0.1";
-// Fun spinner messages that rotate randomly
-const SPINNER_MESSAGES = [
-    "Brainstorming...",
-    "Brewing coffee...",
-    "Sipping espresso...",
-    "Testing theories...",
-    "Making magic...",
-    "Multiplying matrices...",
-];
-function getRandomSpinnerMessage() {
-    return SPINNER_MESSAGES[Math.floor(Math.random() * SPINNER_MESSAGES.length)];
-}
-// Create shimmer effect frames that include the spinner icon
-function createShimmerFrames(text) {
-    const frames = [];
-    const baseText = text;
-    // Ora's default dots spinner frames
-    const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    // Create frames with moving highlight across the text
-    for (let i = 0; i <= baseText.length; i++) {
-        const spinnerIcon = spinnerFrames[i % spinnerFrames.length];
-        const before = chalk.white(baseText.slice(0, i));
-        const current = baseText[i] || '';
-        const after = chalk.white(baseText.slice(i + 1));
-        const shimmerText = before + chalk.cyan.bold(current) + after;
-        frames.push(`${chalk.cyan(spinnerIcon)} ${shimmerText}`);
-    }
-    return frames;
-}
-export async function runAgent(config) {
-    const stats = {
-        startTime: Date.now(),
-        iterations: 0,
-        filesModified: new Set(),
-        commandsRun: [],
-        errors: [],
-    };
-    let claudeCodeStderr = "";
-    logger.setVerbose(config.verbose);
-    // Display metadata
-    logger.raw("");
-    // Get git branch if available
-    let gitBranch = "";
-    try {
-        const { execSync } = await import("node:child_process");
-        gitBranch = execSync("git rev-parse --abbrev-ref HEAD", {
-            encoding: "utf8",
-            stdio: ["pipe", "pipe", "ignore"]
-        }).trim();
-    }
-    catch {
-        // Not in a git repo or git not available
-    }
-    const metadataParts = [
-        chalk.dim("Supatest AI ") + chalk.cyan(`v${CLI_VERSION}`),
-        chalk.dim("Model: ") + chalk.cyan(envConfig.anthropicModelName),
-    ];
-    if (gitBranch) {
-        metadataParts.push(chalk.dim("Branch: ") + chalk.cyan(gitBranch));
-    }
-    logger.raw(metadataParts.join(chalk.dim(" • ")));
-    logger.divider();
-    // Show environment info in verbose mode
-    if (config.verbose) {
-        logger.raw("");
-        logger.debug("Environment & System Info:");
-        // Node.js version
-        logger.debug(`  Node.js: ${process.version}`);
-        // OS & Platform
-        const os = await import("node:os");
-        logger.debug(`  Platform: ${os.platform()} ${os.arch()} (${os.type()} ${os.release()})`);
-        // Working directory
-        logger.debug(`  Working Dir: ${process.cwd()}`);
-        // Git status
-        try {
-            const { execSync } = await import("node:child_process");
-            const gitStatus = execSync("git status --porcelain", {
-                encoding: "utf8",
-                stdio: ["pipe", "pipe", "ignore"]
-            }).trim();
-            const statusText = gitStatus ? "dirty (uncommitted changes)" : "clean";
-            logger.debug(`  Git Status: ${statusText}`);
-        }
-        catch {
-            logger.debug(`  Git Status: not a git repository`);
-        }
-        // Available disk space
-        try {
-            const fs = await import("node:fs");
-            const stats = fs.statfsSync(process.cwd());
-            const availableGB = ((stats.bavail * stats.bsize) / (1024 ** 3)).toFixed(2);
-            logger.debug(`  Available Disk: ${availableGB} GB`);
-        }
-        catch {
-            logger.debug(`  Available Disk: unable to determine`);
-        }
-    }
-    logger.raw("");
-    logger.raw("");
-    logger.raw(chalk.white.bold("Task:") + " " + chalk.cyan(config.task));
-    if (config.logs) {
-        logger.info("Processing provided logs...");
-    }
-    logger.raw("");
-    // Create session on backend and initialize event streaming
-    const apiUrl = config.supatestApiUrl || "https://api.supatest.ai";
-    const apiClient = new ApiClient(apiUrl, config.supatestApiKey);
-    let sessionId;
-    let webUrl;
-    let eventStreamer;
-    try {
-        const session = await apiClient.createSession(config.task, {
-            cliVersion: CLI_VERSION,
-            cwd: process.cwd(),
-        });
-        sessionId = session.sessionId;
-        webUrl = session.webUrl;
-        eventStreamer = new EventStreamer(apiClient, sessionId);
-        logger.raw("");
-        logger.divider();
-        logger.raw(chalk.white.bold("View session live: ") +
-            chalk.cyan.underline(webUrl));
-        logger.divider();
-        logger.raw("");
-    }
-    catch (error) {
-        logger.warn(`Failed to create session on backend: ${error.message}`);
-        logger.warn("Continuing without web streaming...");
-    }
-    logger.raw("");
-    // Initialize spinner variable (will be created on first agent turn)
-    let spinner = null;
-    // Resolve path to Claude Code executable
-    let claudeCodePath;
-    try {
-        // Build the prompt
-        let prompt = config.task;
-        if (config.logs) {
-            prompt = `${config.task}\n\nHere are the logs to analyze:\n\`\`\`\n${config.logs}\n\`\`\``;
-        }
-        const proxyUrl = config.supatestApiUrl || "https://api.supatest.ai";
-        // Build base URL with session ID embedded in the path for message tracking
-        // The proxy will extract the session ID from the path and lookup the message ID in Redis
-        // Format: {proxyUrl}/v1/sessions/{sessionId}/anthropic
-        let baseUrl = `${proxyUrl}/public`;
-        if (sessionId) {
-            baseUrl = `${proxyUrl}/v1/sessions/${sessionId}/anthropic`;
-            if (config.verbose) {
-                logger.debug(`Using session-based proxy URL: ${baseUrl}`);
-            }
-        }
-        process.env.ANTHROPIC_BASE_URL = baseUrl;
-        process.env.ANTHROPIC_API_KEY = config.supatestApiKey;
-        if (config.verbose) {
-            logger.debug(`Using Supatest proxy: ${proxyUrl}/public`);
-            logger.debug(`Supatest API key: ${config.supatestApiKey?.substring(0, 15)}...`);
-        }
-        // Allow override via environment variable for testing/debugging
-        if (envConfig.claudeCodeExecutablePath) {
-            claudeCodePath = envConfig.claudeCodeExecutablePath;
-            if (config.verbose) {
-                logger.debug(`Using CLAUDE_CODE_EXECUTABLE_PATH: ${claudeCodePath}`);
-            }
-        }
-        else {
-            // Determine binary directory
-            // For compiled binaries: same directory as the executable
-            // For development: use the SDK's bundled cli.js from node_modules
-            const isCompiledBinary = process.execPath && !process.execPath.includes("node");
-            if (isCompiledBinary) {
-                // Production: claude-code-cli.js should be next to the binary
-                claudeCodePath = join(dirname(process.execPath), "claude-code-cli.js");
-                if (config.verbose) {
-                    logger.debug(`Production mode: ${claudeCodePath}`);
-                }
-            }
-            else {
-                // Development: use SDK's cli.js from node_modules
-                const require = createRequire(import.meta.url);
-                const sdkPath = require.resolve("@anthropic-ai/claude-agent-sdk/sdk.mjs");
-                claudeCodePath = join(dirname(sdkPath), "cli.js");
-                if (config.verbose) {
-                    logger.debug(`Development mode: ${claudeCodePath}`);
-                }
-            }
-            // Verify the file exists
-            const fs = await import("node:fs/promises");
-            try {
-                await fs.access(claudeCodePath);
-                if (config.verbose) {
-                    logger.debug(`✓ Claude Code CLI found: ${claudeCodePath}`);
-                }
-            }
-            catch {
-                throw new Error(`Claude Code executable not found at: ${claudeCodePath}\n` +
-                    "For compiled binaries, ensure claude-code-cli.js is in the same directory as the binary.\n" +
-                    "Set CLAUDE_CODE_EXECUTABLE_PATH environment variable to override.");
-            }
-        }
-        let resultText = "";
-        let hasError = false;
-        // Log SDK configuration for debugging
-        if (config.verbose) {
-            logger.debug(`\nSDK Configuration:`);
-            logger.debug(`  Prompt: ${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}`);
-            logger.debug(`  Max turns: ${config.maxIterations}`);
-            logger.debug(`  Working directory: ${process.cwd()}`);
-            logger.debug(`  Model: ${envConfig.anthropicModelName}`);
-            logger.debug(`  Claude Code executable: ${claudeCodePath}`);
-            logger.debug(`  Supatest API Key: ${config.supatestApiKey?.substring(0, 10)}...`);
-            logger.debug(`  Environment ANTHROPIC_API_KEY: ${process.env.ANTHROPIC_API_KEY ? 'set' : 'not set'}`);
-        }
-        // Stream initial user message and capture assistant message ID for usage tracking
-        let assistantMessageId;
-        if (eventStreamer && sessionId) {
-            const userMessageEvent = {
-                type: "user_message",
-                content: [{ type: "text", text: prompt }],
-            };
-            const eventResponse = await apiClient.streamEvent(sessionId, userMessageEvent);
-            assistantMessageId = eventResponse.assistantMessageId;
-            if (assistantMessageId && config.verbose) {
-                logger.debug(`Assistant message ID for tracking: ${assistantMessageId}`);
-            }
-        }
-        // Run the agent using the SDK
-        // Note: The proxy will automatically look up the message ID via Redis using the API key
-        const queryOptions = {
-            maxTurns: config.maxIterations,
-            cwd: process.cwd(),
-            model: envConfig.anthropicModelName,
-            permissionMode: "bypassPermissions",
-            allowDangerouslySkipPermissions: true,
-            pathToClaudeCodeExecutable: claudeCodePath,
-            // Enable streaming delta events for real-time updates
-            includePartialMessages: true,
-            // Force Node.js runtime even when running from a Bun binary
-            // The claude-code-cli.js is a large minified JS file that Bun can't parse correctly
-            executable: 'node',
-            // Explicitly pass environment variables to the subprocess
-            env: {
-                ...process.env,
-                ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || '',
-                ANTHROPIC_BASE_URL: process.env.ANTHROPIC_BASE_URL || '',
-                ANTHROPIC_AUTH_TOKEN: '', // Clear stored OAuth token
-                CLAUDE_CODE_AUTH_TOKEN: '', // Clear any other auth tokens
-            },
-            stderr: (msg) => {
-                claudeCodeStderr += msg + "\n";
-                if (config.verbose) {
-                    logger.debug(`[Claude Code stderr] ${msg}`);
-                }
-            },
-        };
-        // Start initial spinner while waiting for first assistant message (skip in silent mode)
-        if (!logger.isSilent()) {
-            const message = getRandomSpinnerMessage();
-            spinner = ora({
-                spinner: {
-                    interval: 80,
-                    frames: createShimmerFrames(message),
-                }
-            });
-            spinner.start();
-        }
-        for await (const msg of query({
-            prompt,
-            options: queryOptions,
-        })) {
-            if (config.verbose) {
-                logger.debug(`Received SDK message: ${msg.type}`);
-            }
-            // Handle different message types
-            if (msg.type === "assistant") {
-                stats.iterations++;
-                if (spinner) {
-                    spinner.stop();
-                }
-                // Extract text content and tool uses
-                const content = msg.message.content;
-                if (Array.isArray(content)) {
-                    for (const block of content) {
-                        if (block.type === "text") {
-                            logger.raw(block.text);
-                            resultText += block.text + "\n";
-                            // WORKAROUND: Since SDK doesn't emit stream_event with includePartialMessages,
-                            // send the complete text as an assistant_text event immediately
-                            if (eventStreamer && block.text) {
-                                const textEvent = {
-                                    type: "assistant_text",
-                                    delta: block.text,
-                                };
-                                await eventStreamer.queueEvent(textEvent);
-                            }
-                        }
-                        else if (block.type === "thinking") {
-                            // Send thinking blocks as well
-                            if (eventStreamer && block.thinking) {
-                                const thinkingEvent = {
-                                    type: "assistant_thinking",
-                                    delta: block.thinking,
-                                };
-                                await eventStreamer.queueEvent(thinkingEvent);
-                            }
-                        }
-                        else if (block.type === "tool_use") {
-                            const toolName = block.name;
-                            const input = block.input;
-                            // Stream tool use event
-                            if (eventStreamer) {
-                                const toolUseEvent = {
-                                    type: "tool_use",
-                                    id: block.id,
-                                    name: toolName,
-                                    input: input || {},
-                                };
-                                await eventStreamer.queueEvent(toolUseEvent);
-                            }
-                            // Display tool calls to user
-                            if (toolName === "Read") {
-                                const filePath = input?.file_path || 'file';
-                                logger.toolRead(filePath);
-                            }
-                            else if (toolName === "Write") {
-                                const filePath = input?.file_path;
-                                if (filePath) {
-                                    stats.filesModified.add(filePath);
-                                    logger.toolWrite(filePath);
-                                }
-                            }
-                            else if (toolName === "Edit") {
-                                const filePath = input?.file_path;
-                                if (filePath) {
-                                    stats.filesModified.add(filePath);
-                                    logger.toolEdit(filePath);
-                                }
-                            }
-                            else if (toolName === "Bash") {
-                                const command = input?.command;
-                                if (command) {
-                                    stats.commandsRun.push(command);
-                                    const shortCmd = command.length > 60 ? `${command.substring(0, 60)}...` : command;
-                                    logger.toolBash(shortCmd);
-                                }
-                            }
-                            else if (toolName === "Glob") {
-                                logger.toolSearch("files", input?.pattern || '');
-                            }
-                            else if (toolName === "Grep") {
-                                logger.toolSearch("code", input?.pattern || '');
-                            }
-                            else if (toolName === "Task") {
-                                logger.toolAgent(input?.subagent_type || 'task');
-                            }
-                            else if (toolName === "TodoWrite") {
-                                const todos = input?.todos;
-                                if (Array.isArray(todos)) {
-                                    logger.todoUpdate(todos);
-                                }
-                                else {
-                                    logger.info("📝 Updated todos");
-                                }
-                            }
-                        }
-                    }
-                }
-                // Stream message_complete event with full content
-                if (eventStreamer) {
-                    // Flush any pending delta events first to ensure they arrive before message_complete
-                    await eventStreamer.flush();
-                    const messageCompleteEvent = {
-                        type: "message_complete",
-                        message: {
-                            role: "assistant",
-                            content: content, // Cast to avoid type mismatch between SDK and shared types
-                        },
-                    };
-                    await eventStreamer.queueEvent(messageCompleteEvent);
-                }
-                logger.raw("");
-                // Stop and clear previous spinner if it exists
-                if (spinner) {
-                    spinner.stop();
-                    spinner.clear();
-                }
-                // Create a new spinner instance with a random message (skip in silent mode)
-                if (!logger.isSilent()) {
-                    const message = getRandomSpinnerMessage();
-                    spinner = ora({
-                        spinner: {
-                            interval: 80,
-                            frames: createShimmerFrames(message),
-                        }
-                    });
-                    spinner.start();
-                }
-            }
-            else if (msg.type === "stream_event") {
-                // NOTE: This code path is currently not triggered due to an SDK issue with includePartialMessages
-                // We've implemented a workaround above to send text immediately when assistant messages arrive
-                // Keeping this code in case future SDK versions fix the streaming support
-                const event = msg.event;
-                if (event.type === "content_block_delta") {
-                    const delta = event.delta;
-                    if (delta.type === "text_delta" && eventStreamer) {
-                        const textDeltaEvent = {
-                            type: "assistant_text",
-                            delta: delta.text,
-                        };
-                        await eventStreamer.queueEvent(textDeltaEvent);
-                    }
-                    else if (delta.type === "thinking_delta" && eventStreamer) {
-                        const thinkingDeltaEvent = {
-                            type: "assistant_thinking",
-                            delta: delta.thinking,
-                        };
-                        await eventStreamer.queueEvent(thinkingDeltaEvent);
-                    }
-                }
-            }
-            else if (msg.type === "tool_progress") {
-                spinner.text = `Using ${msg.tool_name}... (${msg.elapsed_time_seconds.toFixed(1)}s)`;
-            }
-            else if (msg.type === "result") {
-                spinner.stop();
-                stats.iterations = msg.num_turns;
-                if (msg.subtype === "success") {
-                    resultText = msg.result || resultText;
-                }
-                else {
-                    hasError = true;
-                    if ("errors" in msg && Array.isArray(msg.errors)) {
-                        stats.errors.push(...msg.errors);
-                        for (const error of msg.errors) {
-                            logger.error(error);
-                        }
-                    }
-                }
-            }
-        }
-        if (spinner) {
-            spinner.stop();
-        }
-        stats.endTime = Date.now();
-        // Complete usage tracking for this message turn
-        if (assistantMessageId && apiClient) {
-            try {
-                await apiClient.completeUsage(assistantMessageId);
-            }
-            catch (error) {
-                logger.warn(`Failed to complete usage tracking: ${error.message}`);
-                // Don't fail the task if usage tracking fails
-            }
-        }
-        // Generate result
-        const result = {
-            success: !hasError && stats.errors.length === 0,
-            summary: resultText || "Task completed",
-            filesModified: Array.from(stats.filesModified),
-            iterations: stats.iterations,
-            error: stats.errors.length > 0 ? stats.errors.join("; ") : undefined,
-        };
-        // Stream session completion or error
-        if (eventStreamer) {
-            if (result.success) {
-                await eventStreamer.queueEvent({ type: "session_complete" });
-            }
-            else {
-                await eventStreamer.queueEvent({
-                    type: "session_error",
-                    error: result.error || "Unknown error",
-                });
-            }
-            // Flush and shutdown event streamer
-            await eventStreamer.shutdown();
-        }
-        // Print summary
-        const summaryText = generateSummary(stats, result, config.verbose);
-        logger.raw(summaryText);
-        // Display web URL again at the end if available
-        if (webUrl) {
-            logger.raw("");
-            logger.divider();
-            logger.raw(chalk.white.bold("Continue on web: ") +
-                chalk.cyan.underline(webUrl));
-            logger.divider();
-        }
-        return result;
-    }
-    catch (error) {
-        if (spinner) {
-            spinner.stop();
-        }
-        stats.endTime = Date.now();
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Check if this is a Claude Code process error and extract details
-        const isProcessError = errorMessage.includes("Claude Code process exited");
-        let exitCode;
-        let stderr;
-        let stdout;
-        // Try to extract exit code from error message (e.g., "exited with code 1")
-        const exitCodeMatch = errorMessage.match(/exited with code (\d+)/i);
-        if (exitCodeMatch) {
-            exitCode = Number.parseInt(exitCodeMatch[1], 10);
-        }
-        if (error && typeof error === "object") {
-            // Try to extract exit code and process output from error object
-            if ("exitCode" in error && typeof error.exitCode === "number") {
-                exitCode = error.exitCode;
-            }
-            if ("code" in error && typeof error.code === "number") {
-                exitCode = error.code;
-            }
-            if ("stderr" in error) {
-                stderr = String(error.stderr);
-            }
-            if ("stdout" in error) {
-                stdout = String(error.stdout);
-            }
-        }
-        logger.error(`Fatal error: ${errorMessage}`);
-        // Show captured stderr if available
-        if (claudeCodeStderr && claudeCodeStderr.trim()) {
-            logger.error("\nClaude Code stderr output:");
-            logger.error(claudeCodeStderr);
-        }
-        if (isProcessError) {
-            if (exitCode !== undefined) {
-                logger.error(`Claude Code process exited with code ${exitCode}`);
-            }
-            else {
-                logger.error("Claude Code process exited with an error");
-            }
-            // Provide helpful guidance for process errors
-            // Show guidance for exit code 1 or if exit code is unknown
-            if (exitCode === 1 || exitCode === undefined) {
-                logger.warn("\nPossible causes:");
-                logger.warn("  • Task may not be actionable (Claude Code works with code-related tasks)");
-                logger.warn("  • Task description may be too vague or not code-focused");
-                logger.warn("  • API authentication or rate limiting issue");
-                logger.warn("\nTry tasks like:");
-                logger.warn("  • 'Fix the failing tests in calculator.test.js'");
-                logger.warn("  • 'Add error handling to the divide function'");
-                logger.warn("  • 'Create a new file hello.js with a greeting function'");
-                logger.warn("  • 'Update imports to use the new package structure'");
-            }
-        }
-        if (config.verbose && error instanceof Error && error.stack) {
-            logger.error(error.stack);
-        }
-        const result = {
-            success: false,
-            summary: `Failed: ${errorMessage}`,
-            filesModified: Array.from(stats.filesModified),
-            iterations: stats.iterations,
-            error: errorMessage,
-        };
-        // Stream session error and shutdown event streamer
-        if (eventStreamer) {
-            await eventStreamer.queueEvent({
-                type: "session_error",
-                error: errorMessage,
-            });
-            await eventStreamer.shutdown();
-        }
-        const summaryText = generateSummary(stats, result, config.verbose);
-        logger.raw(summaryText);
-        // Display web URL at the end if available
-        if (webUrl) {
-            logger.raw("");
-            logger.divider();
-            logger.raw(chalk.white.bold("View session: ") +
-                chalk.cyan.underline(webUrl));
-            logger.divider();
-        }
-        return result;
-    }
-}

package/dist/prompts/headless.md

@@ -1,97 +0,0 @@
-<role>
-You are an E2E Test Builder Agent that iteratively creates, runs, and fixes Playwright tests until they pass. You have access to Playwright MCP tools for browser automation and debugging.
-</role>
-
-<core_workflow>
-Follow this iterative build loop for each test:
-
-1. **Understand** - Read the test spec or user flow requirements
-2. **Write** - Create or update the Playwright test file
-3. **Run** - Execute the test using the correct command
-4. **Verify** - Check results; if passing, move to next test
-5. **Debug** - If failing, use Playwright MCP tools to investigate
-6. **Fix** - Update test based on findings, return to step 3
-
-Continue until all tests pass. Do NOT stop after first failure.
-</core_workflow>
-
-<playwright_execution>
-CRITICAL: Always run Playwright tests correctly to ensure clean exits.
-
-**Correct test commands:**
-- Single test: `npx playwright test tests/example.spec.ts --reporter=list`
-- All tests: `npx playwright test --reporter=list`
-- Headed mode (debugging): `npx playwright test --headed --reporter=list`
-
-**NEVER use:**
-- `--ui` flag (opens interactive UI that blocks)
-- `--reporter=html` without `--reporter=list` (may open server)
-- Commands without `--reporter=list` in CI/headless mode
-
-**Process management:**
-- Always use `--reporter=list` or `--reporter=dot` for clean output
-- Tests should exit automatically after completion
-- If a process hangs, kill it and retry with correct flags
-</playwright_execution>
-
-<debugging_with_mcp>
-When tests fail, use Playwright MCP tools to investigate:
-
-1. **Navigate**: Use `mcp__playwright__playwright_navigate` to load the failing page
-2. **Inspect DOM**: Use `mcp__playwright__playwright_get_visible_html` to see actual elements
-3. **Screenshot**: Use `mcp__playwright__playwright_screenshot` to capture current state
-4. **Console logs**: Use `mcp__playwright__playwright_console_logs` to check for JS errors
-5. **Interact**: Use click/fill tools to manually reproduce the flow
-
-This visual debugging helps identify:
-- Missing or changed selectors
-- Timing issues (element not ready)
-- Network/API failures
-- JavaScript errors preventing interactions
-</debugging_with_mcp>
-
-<selector_strategy>
-Prioritize resilient selectors:
-1. `getByRole()` - accessibility-focused, most stable
-2. `getByLabel()` - form elements
-3. `getByText()` - user-visible content
-4. `getByTestId()` - explicit test markers
-5. CSS selectors - last resort, avoid class-based
-
-When selectors fail:
-- Use MCP to inspect actual DOM structure
-- Check if element exists but has different text/role
-- Verify element is visible and not hidden
-</selector_strategy>
-
-<test_quality>
-Write production-ready tests:
-- **Arrange-Act-Assert** structure for clarity
-- **Explicit waits** over arbitrary timeouts
-- **Independent tests** that don't share state
-- **Meaningful assertions** that verify outcomes
-
-Avoid:
-- `waitForTimeout()` - use explicit element waits
-- Brittle selectors based on CSS classes
-- Tests that depend on execution order
-- Vague assertions like `toBeTruthy()`
-</test_quality>
-
-<iteration_mindset>
-Expect multiple iterations. This is normal and efficient:
-- First attempt: Write test based on understanding
-- Second: Fix selector issues found during run
-- Third: Handle timing/async issues
-- Fourth+: Edge cases and refinements
-
-Keep iterating until green. Three robust passing tests are better than ten flaky ones.
-</iteration_mindset>
-
-<communication>
-When reporting progress:
-- State which test is being worked on
-- Report pass/fail status after each run
-- When fixing, explain what was wrong and the fix
-- Summarize final status: X/Y tests passing
-</communication>