@delt/tester-mcp 0.1.0

package/README.md

@@ -0,0 +1,36 @@
+# @delt/tester-mcp
+
+Opus (planner) + Haiku (executor) + Chrome screen E2E test orchestrator.
+The CLI spawns `claude -p --chrome` per scenario and reports one of four labels:
+PASS / PARTIAL / FAIL / NOT_TESTED.
+
+## Install
+
+```
+npm i -g @delt/tester-mcp
+tester-mcp init          # installs the skill, scaffolds config + secrets example
+```
+
+## Use
+
+```
+tester-mcp run scenarios/<area>/<id>.yaml -c tester-mcp.config.yaml
+```
+
+## Authoring & prerequisites
+
+This tool is designed to be driven by an AI agent. The authoritative,
+version-pinned reference for prerequisites and the scenario DSL is the CLI itself:
+
+```
+tester-mcp document-guide
+```
+
+Run that before writing scenarios. (This README intentionally does not duplicate
+those facts — the command is the single source of truth.)
+
+## Scenarios live in your project, not here
+
+Scenario YAML files belong to the project under test — commit them to that repo.
+For a minimal example, run `tester-mcp document-guide`; it includes a sample
+scenario.

package/bin/tester-mcp.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,106 @@
+import { Command } from "commander";
+import { resolve, join, dirname } from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "./config/loadConfig.js";
+import { parseScenario } from "./scenario/parseScenario.js";
+import { resolveSecrets } from "./secrets/resolveSecrets.js";
+import { loadSecretsFile } from "./secrets/loadSecretsFile.js";
+import { collectSecretValues, redactSecrets } from "./secrets/redactSecrets.js";
+import { runInit } from "./init.js";
+import { runScenarios, clampConcurrency, MAX_CONCURRENCY } from "./run/runScenarios.js";
+import { expandScenarioPaths } from "./scenario/expandScenarioPaths.js";
+import { writeScenarioResult, writeSummary } from "./result/writeResult.js";
+import { captureEnv } from "./env/captureEnv.js";
+import { makeRunId } from "./util/runId.js";
+import { loadGuide } from "./guide/loadGuide.js";
+const program = new Command();
+program.name("tester-mcp").description("Opus+Haiku+Chrome 통합 테스트 (Phase 1: 화면검증)");
+// [확장5] validate/report/diff 는 여기에 .command() 추가.
+program
+    .command("run")
+    .argument("<scenarios...>", "시나리오 YAML 경로(파일/디렉토리, 여러 개 가능)")
+    .option("-c, --config <path>", "설정 파일", "tester-mcp.config.yaml")
+    .option("--secrets <path>", "시크릿 파일", "tester-mcp.secrets.yaml")
+    .option("--front-dir <path>", "frontend git 디렉토리(commit 캡처)")
+    .option("--timeout <ms>", "executor 하드 타임아웃(ms, config runner.timeout_ms 오버라이드)")
+    .option("--concurrency <n>", `병렬 executor 수(1~${MAX_CONCURRENCY}, 기본 min(시나리오 수, ${MAX_CONCURRENCY}))`)
+    .option("--verbose", "executor 이벤트를 콘솔에 실시간 출력")
+    .option("--out-dir <path>", "결과/로그 출력 베이스 디렉토리(기본 runs)", "runs")
+    .action(async (scenarioPaths, opts) => {
+    try {
+        const config = loadConfig(resolve(opts.config));
+        const secrets = loadSecretsFile(resolve(opts.secrets));
+        const files = expandScenarioPaths(scenarioPaths);
+        const scenarios = files.map((f) => parseScenario(readFileSync(f, "utf8")));
+        const runId = makeRunId();
+        const runDir = join(opts.outDir ?? "runs", runId);
+        const env = captureEnv({ model: config.runner.model, frontendDir: opts.frontDir });
+        const timeoutMs = opts.timeout ? Number(opts.timeout) : config.runner.timeout_ms;
+        const concurrency = clampConcurrency(opts.concurrency ? Number(opts.concurrency) : undefined, scenarios.length);
+        if (scenarios.length > 1)
+            console.log(`시나리오 ${scenarios.length}개 · 병렬 ${concurrency}`);
+        // Compute secret values before run so they can be redacted in streaming logs.
+        const secretValues = collectSecretValues({ secrets, env: process.env });
+        const results = await runScenarios(scenarios, {
+            runId,
+            targets: { frontend: config.targets.frontend },
+            model: config.runner.model,
+            env,
+            resolveValue: (v) => resolveSecrets(v, { secrets }),
+            timeoutMs,
+        }, concurrency, { verbose: opts.verbose, secretValues, outDir: opts.outDir ?? "runs" });
+        const safe = results.map((r) => redactSecrets(r, secretValues));
+        const startedAt = safe[0]?.started_at ?? new Date().toISOString();
+        for (const s of safe) {
+            writeScenarioResult(runDir, s);
+            console.log(`[${s.status}] ${s.scenario_id} → ${join(runDir, s.scenario_id + ".json")}`);
+            if (s.evidence?.length)
+                console.log("  evidence:", s.evidence.join(" | "));
+        }
+        writeSummary(runDir, runId, startedAt, safe);
+        // Exit 0 only if every scenario passed or partially passed.
+        const ok = safe.every((s) => s.status === "PASS" || s.status === "PARTIAL");
+        process.exit(ok ? 0 : 1);
+    }
+    catch (err) {
+        console.error("실행 오류:", err instanceof Error ? err.message : err);
+        process.exit(2);
+    }
+});
+program
+    .command("init")
+    .description("스킬·설정·시크릿 예시를 설치하는 셋업 마법사")
+    .option("--global", "전역 스킬 설치(~/.claude/skills)")
+    .option("--project [path]", "프로젝트 스킬 설치(<path>/.claude/skills, 기본 cwd)")
+    .option("--frontend <url>", "frontend URL")
+    .option("--backend <url>", "backend URL(선택)")
+    .option("--model <m>", "executor 모델")
+    .option("--yes", "비대화형(기본값/플래그 사용)")
+    .action(async (opts) => {
+    try {
+        await runInit(opts);
+    }
+    catch (err) {
+        console.error("init 오류:", err instanceof Error ? err.message : err);
+        process.exit(2);
+    }
+});
+program
+    .command("document-guide")
+    .description("Print the authoring guide (prerequisites + scenario DSL) to stdout")
+    .action(() => {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const guide = loadGuide(here, {
+            exists: existsSync,
+            read: (p) => readFileSync(p, "utf8"),
+        });
+        process.stdout.write(guide.endsWith("\n") ? guide : guide + "\n");
+    }
+    catch (err) {
+        console.error("document-guide error:", err instanceof Error ? err.message : err);
+        process.exit(2);
+    }
+});
+program.parseAsync();

package/dist/config/loadConfig.d.ts

@@ -0,0 +1,14 @@
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+export interface Config {
+    project: string;
+    targets: {
+        frontend: string;
+        backend?: string;
+    };
+    runner: {
+        model: string;
+        timeout_ms: number;
+    };
+}
+export declare function parseConfig(yamlText: string): Config;
+export declare function loadConfig(path: string): Config;

package/dist/config/loadConfig.js

@@ -0,0 +1,20 @@
+import { readFileSync } from "node:fs";
+import { parse as parseYaml } from "yaml";
+export const DEFAULT_TIMEOUT_MS = 300_000; // 5분 — executor 하드 타임아웃 기본값
+export function parseConfig(yamlText) {
+    const raw = (parseYaml(yamlText) ?? {});
+    const frontend = raw?.targets?.frontend;
+    if (typeof frontend !== "string")
+        throw new Error("설정 필수 필드 누락: targets.frontend");
+    return {
+        project: typeof raw.project === "string" ? raw.project : "unknown",
+        targets: { frontend, backend: raw?.targets?.backend },
+        runner: {
+            model: raw?.runner?.model ?? "haiku",
+            timeout_ms: typeof raw?.runner?.timeout_ms === "number" ? raw.runner.timeout_ms : DEFAULT_TIMEOUT_MS,
+        },
+    };
+}
+export function loadConfig(path) {
+    return parseConfig(readFileSync(path, "utf8"));
+}

package/dist/env/captureEnv.d.ts

@@ -0,0 +1,8 @@
+import type { Environment } from "../result/types.js";
+export interface CaptureEnvOptions {
+    model: string;
+    frontendDir?: string;
+    backendDir?: string;
+    gitSha?: (dir: string) => string | undefined;
+}
+export declare function captureEnv(opts: CaptureEnvOptions): Environment;

package/dist/env/captureEnv.js

@@ -0,0 +1,20 @@
+import { execFileSync } from "node:child_process";
+function realGitSha(dir) {
+    try {
+        return execFileSync("git", ["-C", dir, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function captureEnv(opts) {
+    const gitSha = opts.gitSha ?? realGitSha;
+    return {
+        frontend_commit: opts.frontendDir ? gitSha(opts.frontendDir) : undefined,
+        backend_commit: opts.backendDir ? gitSha(opts.backendDir) : undefined,
+        browser: "chrome (claude-in-chrome)",
+        runner_model: opts.model,
+        node_version: process.version,
+        os: process.platform,
+    };
+}

package/dist/guide/loadGuide.d.ts

@@ -0,0 +1,6 @@
+export interface GuideFs {
+    exists(p: string): boolean;
+    read(p: string): string;
+}
+export declare function findGuidePath(startDir: string, exists: (p: string) => boolean): string | undefined;
+export declare function loadGuide(startDir: string, fs: GuideFs): string;

package/dist/guide/loadGuide.js

@@ -0,0 +1,23 @@
+import { join, dirname } from "node:path";
+// Walk up from startDir looking for skills/tester-mcp/document-guide.md.
+// Works for dist/ (pkg root two levels up) and src/ via tsx (one level up).
+export function findGuidePath(startDir, exists) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+        const candidate = join(dir, "skills", "tester-mcp", "document-guide.md");
+        if (exists(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+export function loadGuide(startDir, fs) {
+    const path = findGuidePath(startDir, fs.exists);
+    if (!path) {
+        throw new Error("document-guide.md not found. Reinstall the package or run from the project root.");
+    }
+    return fs.read(path);
+}

package/dist/init.d.ts

@@ -0,0 +1,17 @@
+export declare function renderConfigYaml(o: {
+    frontend: string;
+    backend?: string;
+    model: string;
+}): string;
+export declare function skillsDirFor(scope: "global" | "project", projectPath: string, home: string): string;
+export declare function secretsExampleYaml(): string;
+export declare function findBundledSkill(startDir: string): string | undefined;
+export interface InitOptions {
+    global?: boolean;
+    project?: string | boolean;
+    frontend?: string;
+    backend?: string;
+    model?: string;
+    yes?: boolean;
+}
+export declare function runInit(opts: InitOptions): Promise<void>;

package/dist/init.js

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { createInterface } from "node:readline/promises";
+// ── PURE testable helpers ────────────────────────────────────────────────
+export function renderConfigYaml(o) {
+    const lines = ["targets:", `  frontend: ${o.frontend}`];
+    if (o.backend)
+        lines.push(`  backend: ${o.backend}`);
+    lines.push("runner:", `  model: ${o.model}`);
+    return lines.join("\n") + "\n";
+}
+export function skillsDirFor(scope, projectPath, home) {
+    return scope === "global"
+        ? join(home, ".claude", "skills")
+        : join(projectPath, ".claude", "skills");
+}
+export function secretsExampleYaml() {
+    return ["tester:", '  username: "YOUR_ID"', '  password: "YOUR_PASSWORD"', ""].join("\n");
+}
+// ── thin glue (not unit-tested) ──────────────────────────────────────────
+// Locate the bundled skill by walking up from the running file looking for a
+// directory containing skills/tester-mcp/SKILL.md. Works for dist/ (pkgRoot two
+// levels up) and src/ via tsx (pkgRoot one level up).
+export function findBundledSkill(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+        const candidate = join(dir, "skills", "tester-mcp", "SKILL.md");
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+export async function runInit(opts) {
+    const nonInteractive = !!opts.yes;
+    let scope;
+    let projectPath = typeof opts.project === "string" ? opts.project : process.cwd();
+    let frontend = opts.frontend;
+    let backend = opts.backend;
+    let model = opts.model;
+    // Determine scope from flags.
+    if (opts.global)
+        scope = "global";
+    else if (opts.project !== undefined)
+        scope = "project";
+    else
+        scope = nonInteractive ? "project" : "project"; // default project; may be overridden interactively
+    if (!nonInteractive) {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            if (!opts.global && opts.project === undefined) {
+                const ans = (await rl.question("스킬 설치 범위 [project/global] (project): ")).trim();
+                if (ans === "global")
+                    scope = "global";
+            }
+            if (scope === "project" && typeof opts.project !== "string") {
+                const ans = (await rl.question(`프로젝트 경로 (${projectPath}): `)).trim();
+                if (ans)
+                    projectPath = ans;
+            }
+            if (frontend === undefined) {
+                const ans = (await rl.question("frontend URL (http://localhost:5173): ")).trim();
+                frontend = ans || "http://localhost:5173";
+            }
+            if (backend === undefined) {
+                const ans = (await rl.question("backend URL (선택, 비우면 생략): ")).trim();
+                backend = ans || undefined;
+            }
+            if (model === undefined) {
+                const ans = (await rl.question("model (haiku): ")).trim();
+                model = ans || "haiku";
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    // Apply defaults for non-interactive / unfilled values.
+    frontend = frontend || "http://localhost:5173";
+    model = model || "haiku";
+    const home = homedir();
+    const cwd = process.cwd();
+    const configDir = scope === "project" ? projectPath : cwd;
+    // 1) Copy bundled skill.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const bundled = findBundledSkill(here);
+    const skillsDir = skillsDirFor(scope, projectPath, home);
+    const destSkill = join(skillsDir, "tester-mcp", "SKILL.md");
+    if (bundled) {
+        mkdirSync(dirname(destSkill), { recursive: true });
+        writeFileSync(destSkill, readFileSync(bundled, "utf8"), "utf8");
+        console.log(`스킬 복사: ${destSkill}`);
+    }
+    else {
+        console.warn("경고: 번들 스킬(skills/tester-mcp/SKILL.md)을 찾지 못했습니다. 스킬 복사를 건너뜁니다.");
+    }
+    // 2) Write config.
+    const configPath = join(configDir, "tester-mcp.config.yaml");
+    mkdirSync(dirname(configPath), { recursive: true });
+    writeFileSync(configPath, renderConfigYaml({ frontend, backend, model }), "utf8");
+    console.log(`설정 작성: ${configPath}`);
+    // 3) Scaffold secrets example + ensure .gitignore.
+    const examplePath = join(cwd, "tester-mcp.secrets.example.yaml");
+    writeFileSync(examplePath, secretsExampleYaml(), "utf8");
+    console.log(`시크릿 예시 작성: ${examplePath}`);
+    const gitignorePath = join(cwd, ".gitignore");
+    const entry = "tester-mcp.secrets.yaml";
+    let gi = existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf8") : "";
+    if (!gi.split(/\r?\n/).some((l) => l.trim() === entry)) {
+        if (gi.length && !gi.endsWith("\n"))
+            gi += "\n";
+        gi += entry + "\n";
+        writeFileSync(gitignorePath, gi, "utf8");
+        console.log(`.gitignore 갱신: ${entry} 추가`);
+    }
+    // 4) Next steps.
+    console.log("\n다음 단계:");
+    console.log(`  1) cp tester-mcp.secrets.example.yaml tester-mcp.secrets.yaml`);
+    console.log(`     → 테스트 계정(username/password)을 채우세요. (이 파일은 gitignore됨)`);
+    console.log(`  2) 시나리오 작성 후 실행:`);
+    console.log(`     tester-mcp run scenarios/<area>/<id>.yaml -c ${join(configDir, "tester-mcp.config.yaml")}`);
+}

package/dist/result/parseExecutorResult.d.ts

@@ -0,0 +1,11 @@
+import { type Status } from "./types.js";
+export interface PartialResult {
+    status: Status;
+    evidence?: string[];
+    steps?: any[];
+    handoff_notes?: string;
+    not_tested_reason?: string;
+    pattern_inference?: "assumed_ok" | "unknown";
+    raw_executor_text?: string;
+}
+export declare function parseExecutorResult(resultText: string): PartialResult;

package/dist/result/parseExecutorResult.js

@@ -0,0 +1,29 @@
+import { STATUSES } from "./types.js";
+function extractJson(text) {
+    const fenced = text.match(/```json\s*([\s\S]*?)```/i);
+    const candidate = fenced ? fenced[1] : text;
+    const start = candidate.indexOf("{"), end = candidate.lastIndexOf("}");
+    if (start === -1 || end <= start)
+        return null;
+    try {
+        return JSON.parse(candidate.slice(start, end + 1));
+    }
+    catch {
+        return null;
+    }
+}
+export function parseExecutorResult(resultText) {
+    const obj = extractJson(resultText);
+    if (!obj || typeof obj !== "object")
+        return { status: "NOT_TESTED", not_tested_reason: "executor 출력 JSON 파싱 실패", raw_executor_text: resultText };
+    if (!STATUSES.includes(obj.status))
+        return { status: "NOT_TESTED", not_tested_reason: `status 라벨이 4종 아님: ${String(obj.status)}`, raw_executor_text: resultText };
+    return {
+        status: obj.status,
+        evidence: Array.isArray(obj.evidence) ? obj.evidence : undefined,
+        steps: Array.isArray(obj.steps) ? obj.steps : undefined,
+        handoff_notes: typeof obj.handoff_notes === "string" ? obj.handoff_notes : undefined,
+        not_tested_reason: typeof obj.not_tested_reason === "string" ? obj.not_tested_reason : undefined,
+        pattern_inference: obj.pattern_inference,
+    };
+}

package/dist/result/types.d.ts

@@ -0,0 +1,44 @@
+export type Status = "PASS" | "PARTIAL" | "FAIL" | "NOT_TESTED";
+export declare const STATUSES: Status[];
+export interface StepResult {
+    index: number;
+    action: string;
+    status: Status;
+    error?: string;
+    screenshot?: string;
+}
+export interface Environment {
+    frontend_commit?: string;
+    backend_commit?: string;
+    browser?: string;
+    runner_model?: string;
+    node_version: string;
+    os: string;
+}
+export interface ScenarioResult {
+    run_id: string;
+    scenario_id: string;
+    status: Status;
+    not_tested_reason?: string;
+    pattern_inference?: "assumed_ok" | "unknown";
+    evidence?: string[];
+    started_at: string;
+    duration_ms: number;
+    steps: StepResult[];
+    environment: Environment;
+    handoff_notes?: string;
+    raw_executor_text?: string;
+    last_tool?: string;
+    tool_count?: number;
+    executor_log?: string;
+}
+export interface RunSummary {
+    run_id: string;
+    started_at: string;
+    total: number;
+    by_status: Record<Status, number>;
+    scenarios: {
+        scenario_id: string;
+        status: Status;
+    }[];
+}

package/dist/result/types.js

@@ -0,0 +1 @@
+export const STATUSES = ["PASS", "PARTIAL", "FAIL", "NOT_TESTED"];

package/dist/result/writeResult.d.ts

@@ -0,0 +1,3 @@
+import { type ScenarioResult } from "./types.js";
+export declare function writeScenarioResult(runDir: string, result: ScenarioResult): string;
+export declare function writeSummary(runDir: string, runId: string, startedAt: string, results: ScenarioResult[]): string;

package/dist/result/writeResult.js

@@ -0,0 +1,22 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { STATUSES } from "./types.js";
+export function writeScenarioResult(runDir, result) {
+    mkdirSync(runDir, { recursive: true });
+    const p = join(runDir, `${result.scenario_id}.json`);
+    writeFileSync(p, JSON.stringify(result, null, 2), "utf8");
+    return p;
+}
+export function writeSummary(runDir, runId, startedAt, results) {
+    mkdirSync(runDir, { recursive: true });
+    const byStatus = Object.fromEntries(STATUSES.map((s) => [s, 0]));
+    for (const r of results)
+        byStatus[r.status]++;
+    const summary = {
+        run_id: runId, started_at: startedAt, total: results.length, by_status: byStatus,
+        scenarios: results.map((r) => ({ scenario_id: r.scenario_id, status: r.status })),
+    };
+    const p = join(runDir, "summary.json");
+    writeFileSync(p, JSON.stringify(summary, null, 2), "utf8");
+    return p;
+}

package/dist/run/buildExecutorArgs.d.ts

@@ -0,0 +1,6 @@
+export interface ExecutorArgsOptions {
+    prompt: string;
+    systemPrompt: string;
+    model: string;
+}
+export declare function buildExecutorArgs(o: ExecutorArgsOptions): string[];

package/dist/run/buildExecutorArgs.js

@@ -0,0 +1,39 @@
+export function buildExecutorArgs(o) {
+    // Flag set verified by live smoke tests against claude -p --chrome:
+    // - --dangerously-skip-permissions: required so chrome tools (navigate/click) auto-run.
+    //   (--permission-mode dontAsk BLOCKS them → executor stalls on a permission prompt.)
+    // - NO --bare: --bare skips auth context too → executor fails with "Not logged in".
+    //   (--bare would only work with ANTHROPIC_API_KEY env; OAuth/keychain are never read.)
+    // - --strict-mcp-config + empty --mcp-config: load NO ambient MCP servers
+    //   (obsidian/alarm/gmail/...). chrome tools still come from --chrome (verified: a
+    //   smoke run reported chrome_tools_available=yes and read example.com under this combo),
+    //   so this trims unused MCP tool schemas + instructions from the executor's context.
+    // - --exclude-dynamic-system-prompt-sections: move per-machine bits (cwd/env/git) out of
+    //   the system prompt → better cross-process prompt-cache reuse across parallel/repeat runs.
+    return [
+        "-p", o.prompt,
+        "--chrome",
+        "--model", o.model,
+        "--append-system-prompt", o.systemPrompt,
+        "--output-format", "stream-json",
+        "--verbose", // stream-json requires --verbose; emits per-event JSON lines
+        "--dangerously-skip-permissions",
+        "--no-session-persistence",
+        "--strict-mcp-config",
+        "--mcp-config", JSON.stringify({ mcpServers: {} }),
+        "--exclude-dynamic-system-prompt-sections",
+        // ── Isolation (verified live 2026-05-26) ──
+        // Without these the executor inherits the HOST environment — project/global
+        // CLAUDE.md, the SessionStart "superpowers" hook, and all skills — and gets
+        // hijacked into the doc/skill workflow: it calls Skill, spawns subagents (Task),
+        // and runs Bash/Write/Edit/Read, never touching the browser, until the timeout.
+        // (Live diagnostic: WITHOUT these → zero chrome tool calls; WITH these → immediate
+        // mcp__claude-in-chrome__* calls.) --bare would also strip all this but breaks
+        // OAuth/keychain auth ("Not logged in"), so we strip piecemeal instead.
+        "--disable-slash-commands", // no Skill invocation
+        "--setting-sources", "user", // skip project/local settings (hooks/config)
+        "--settings", JSON.stringify({ disableAllHooks: true }), // no hooks (SessionStart)
+        "--disallowedTools", // hard-deny the wandering tools
+        "Skill,Task,Agent,Bash,Write,Edit,Read,NotebookEdit,Glob,Grep,WebFetch,WebSearch",
+    ];
+}

package/dist/run/buildPrompt.d.ts

@@ -0,0 +1,7 @@
+import type { Scenario, Locale } from "../scenario/types.js";
+export declare const SYSTEM_CONTRACT = "You are a screen integration-test executor. Execute ONLY the given scenario steps, in order. Be fast and simple \u2014 act on the given selector, look as little as possible, and bail immediately if you can't.\n\n[Tab isolation \u2014 parallel safety (do this FIRST)]\n- You share one Chrome with other executors. Your very first action: create your OWN new tab with tabs_create_mcp. Never reuse an existing tab that tabs_context shows (another executor may be using it). Remember that new tab_id and do EVERY action (navigate/click/fill/find/screenshot) ONLY in that tab_id.\n- If the current tab's URL is unrelated to your scenario (= you landed on someone else's tab), end immediately with NOT_TESTED and record \"tab mix-up: observed URL=\u2026\" in handoff_notes. Do not keep working on someone else's tab.\n\n[Finding elements \u2014 selector first]\n- Try the strategies given in the step's target, in order (css \u2192 placeholder \u2192 label \u2192 text \u2192 role \u2192 description), ONCE.\n- Do not grope around the page. The target is the answer.\n\n[Read minimally]\n- No full-page reads: do not call read_page (full accessibility tree) or a full get_page_text.\n- Use a targeted find to see only that element. assert_visible checks only that element.\n\n[Screenshots \u2014 evidence only, not the verdict]\n- Decide PASS/FAIL by assert (text/DOM). A screenshot is human-facing evidence, not the basis for the verdict.\n- Take a screenshot only when the scenario has a screenshot action, best-effort, once. If you can't capture it (element gone, capture failed, timeout), just skip and move on. NEVER loop re-triggering/resizing/scrolling/re-capturing. A failed screenshot is not a test failure.\n\n[Ephemeral (auto-dismissing) UI]\n- For short-lived elements (toast, snackbar), check IMMEDIATELY and ONCE right after the trigger (the fastest way: a JS text/DOM assertion). Do not chain fallbacks (JS \u2192 find \u2192 read_page) \u2014 the element vanishes mid-chain.\n- Do not screenshot an ephemeral element. The assertion is the proof.\n\n[Fast self-bail \u2014 once]\n- If you can't find the target in one attempt, or a browser tool returns no/empty response once, end immediately with NOT_TESTED. Do not retry the same heavy call.\n- One failure means the scenario (selector) is wrong \u2014 don't try to recover, hand it to the builder.\n\n[Status labels] status is exactly one of four:\n- PASS: behaved as expected (verified)\n- PARTIAL: only partly verified, or a non-critical difference\n- FAIL: behaved differently than expected (a bug)\n- NOT_TESTED: couldn't trigger \u2014 must include not_tested_reason and handoff_notes\n\n[handoff_notes \u2014 fuel for the ping-pong] On NOT_TESTED, must include:\n- the failed step number\n- the target strategies you tried\n- what you actually observed on screen (a single targeted query at the failure point is allowed to write this \u2014 full dumps are still forbidden)\n- a fix suggestion for the builder (e.g. css `#login-btn` does not exist, observed `.p-button[aria-label='\u0412\u043E\u0439\u0442\u0438']` \u2192 suggest replacing target.css)\n\n[Safety \u2014 forbidden]\n- Never do anything outside the scenario (especially delete/publish/send).\n- Avoid clicks that raise a JS alert/confirm/prompt (they freeze the session). If unavoidable, NOT_TESTED.\n- No absolute claims like \"100% safe\". Do not mix verified facts with assumptions.\n- Never write entered secrets (passwords etc.) into evidence/output verbatim \u2014 mask them as '***'.\n\n[Output] Emit the result as a JSON object only in the last message (a code fence is allowed). No free-form prose.";
+export interface PromptTargets {
+    frontend: string;
+}
+export declare function localeToLanguageType(locale: Locale): string;
+export declare function buildUserPrompt(scenario: Scenario, targets: PromptTargets, resolveValue: (v: string) => string): string;