testeiya 0.2.0 → 0.3.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Testomat.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,212 +1,74 @@
 # Testeiya
 
-AI-powered testing agent for QA teams, built on top of the [oh-my-pi](https://github.com/can1357/oh-my-pi) coding-agent SDK (a fork of [Pi](https://github.com/badlogic/pi-mono) by Mario Zechner).
+An agent, app, and the goddess of testing.
 
-## About
+Testeiya is a QA-focused AI agent. It reads and writes manual test cases as markdown, works with automated test code, and talks to [Testomat.io](https://testomat.io) as a test management system. It ships as a desktop app, a web app, and the command-line agent in this repository.
 
-Testeiya is an interactive terminal agent that helps developers analyze test suites, find coverage gaps, and plan testing strategies. It reads your codebase aggressively while keeping write operations locked down, so you can safely point it at any project.
+This repository holds the parts of Testeiya that shape how the agent thinks:
 
-It ships with [Testomat.io](https://testomat.io) skills for test case management and connects to any OpenAI-compatible API (default: [OpenRouter](https://openrouter.ai)).
+| Folder | What it is |
+|---|---|
+| `prompt/` | The system-prompt fragments — the agent's role, rules, tool guidance, Testomat.io operating rules, and the report contract |
+| `skills/` | The manifest of skills the agent can invoke — every folder is fetched from its own upstream repository |
+| `src/` | The `testeiya` command-line agent (Node) |
 
-## Features
+The desktop and web harness — servers, session management, sync, UI — is not open source.
 
-- QA-focused system prompt tuned for test analysis
-- Read-permissive / write-restricted permission model
-- Safe bash commands (git log, cat, grep...) auto-allowed; destructive commands blocked
-- Testomat.io skills: test generation, duplicate detection, test improvement, reporter setup
-- Markdown-rendered output in terminal
-- Multi-line paste support
-- Configurable LLM provider and model (OpenRouter by default; any OpenAI-compatible endpoint)
-
-## Installation
-
-```bash
-npm install -g testeiya    # requires Bun (https://bun.sh) on your PATH
-testeiya
-```
-
-Or run from source. This package lives in the [`cli/`](https://github.com/testomatio/testeiya-app/tree/main/cli) directory of the Testeiya monorepo:
+## Install and use
 
 ```bash
-git clone git@github.com:testomatio/testeiya-app.git
-cd testeiya-app/cli
-bun install
-bun src/cli.ts
+npx testeiya "Review the manual tests in this folder and list the gaps" \
+  --model openrouter/anthropic/claude-sonnet-5 --output report.md
 ```
 
-### Requirements
-
-- [Bun](https://bun.sh) — the CLI runs under Bun (its `testeiya` bin uses a `#!/usr/bin/env bun` shebang and runs the TypeScript directly)
-- An API key for whatever you set as `provider.name` in config (default is OpenRouter; see [API keys](#api-keys) below)
-
-## Running in Container (Optional)
-
-Instead of installing locally, you can run Testeiya in Docker. Requires [Docker](https://docker.com) to be installed.
-
-```bash
-# Build the container
-make build
-
-# Configure environment (copy example and edit)
-cp .env.example .env
-# Edit .env with your API keys
+The agent runs one task and exits — there is no interactive mode. Progress goes to stderr, the report to `--output` (or stdout when you omit it). Exit codes: `0` pass, `1` failed run or negative verdict, `2` bad usage, `130` interrupted — so it drops into CI as-is.
 
-# Run the container
-make run
-
-# Stop the container
-make stop
-
-# Clean up containers
-make clean
-```
-
-The container mounts `./src` to `/app/src`, so you can edit code locally and run it inside the container.
-
-### MCP (Testomat.io Integration)
-
-Testeiya includes MCP server for Testomat.io. To enable:
-
-1. Copy `.env.example` to `.env`
-2. Add your Testomat.io credentials:
-
-```bash
-# In .env file
-OPENROUTER_API_KEY=sk-or-your-key
-TESTOMATIO_PROJECT_TOKEN=tstmt_xxx
-TESTOMATIO_PROJECT_ID=your-project-id
-TESTOMATIO_BASE_URL=https://app.testomat.io # or any anoher one
-```
+Requires Node 22.19 or newer, a model, and an LLM provider key.
 
-3. Run `make run` - MCP will auto-connect
+There is no default model. Name one with `--model <provider>/<id>` or `TESTEIYA_MODEL`; a run that names none exits `2` rather than spending your money on a model nobody chose.
 
-## Usage
+The key comes from the environment (`OPENROUTER_API_KEY` and friends), `~/.testeiya/.env`, or `~/.testeiya/auth.json` — the same file the desktop app's Settings dialog writes, so configuring it once covers both.
 
 ```bash
-export OPENROUTER_API_KEY=sk-or-your-key-here
-bun src/cli.ts
+testeiya --help                      # every flag
+export TESTEIYA_MODEL=openrouter/anthropic/claude-sonnet-5
+testeiya "<task>"
+cat task.md | testeiya --output report.md
 ```
 
-Or build and run with Node:
+Set `TESTOMATIO` to a project API key and the agent can read and write that project's tests, suites, runs and plans through `check-tests` and the REST API. Add the project id as well and it also gets the Testomat.io tools:
 
 ```bash
-npm run build
-node dist/cli.js
+TESTOMATIO=tstmt_xxx testeiya --project my-project "Which suites have no tests?"
 ```
 
-You'll see:
-
-```
-  Model: openrouter/anthropic/claude-sonnet-4
-  Skills: analyze-tests, find-duplicate-cases, generate-test-cases, ...
-
-  Testeiya - AI Testing Agent
-
-  What can I do for you?
-```
-
-Type a request like:
-
-- "Analyze the test suite in this project"
-- "Find untested code paths in src/controllers"
-- "Generate test cases for the auth module"
-
-Paste multi-line text (API docs, specs, requirements) directly into the prompt.
-
-## Configuration
-
-Edit `testeiya.config.json` in the project root:
-
-```json
-{
-  "provider": {
-    "name": "openrouter",
-    "baseUrl": "https://openrouter.ai/api/v1",
-    "model": "anthropic/claude-sonnet-4",
-    "contextWindow": 200000,
-    "maxTokens": 16384
-  },
-  "permissions": {
-    "autoAllowRead": true,
-    "blockWrites": true,
-    "blockBash": true
-  }
-}
-```
-
-- **provider.model** - Any model available on OpenRouter (e.g. `anthropic/claude-sonnet-4`, `openai/gpt-4o`, `google/gemini-2.5-pro`)
-- **permissions.blockWrites** - When `true`, edit/write tools are blocked
-- **permissions.blockBash** - When `true`, only read-only bash commands are allowed
-
-Config is also loaded from `~/.testeiya/config.json` as a fallback.
-
-### API keys
-
-Read the API key from `process.env.<PROVIDER_NAME>_API_KEY`, where `<PROVIDER_NAME>` is your `provider.name` (uppercase) from config (e.g. `openrouter` in `testeiya.config.json`).
-
-Example: if `provider.name` is `openrouter`, read the API key from `process.env.OPENROUTER_API_KEY`.
-
-| `provider.name` | Environment variable   |
-| --------------- | ---------------------- |
-| `openrouter`    | `OPENROUTER_API_KEY`   |
-| `openai`        | `OPENAI_API_KEY`       |
-| `anthropic`     | `ANTHROPIC_API_KEY`    |
-| `groq`          | `GROQ_API_KEY`         |
-
-Or set any environment variable name depending of provider name.
+The id can come from `--project` or `TESTOMATIO_PROJECT_ID`. The MCP server needs it: a token alone does not tell it which project to talk to.
 
 ## Skills
 
-Testeiya loads skills from [@testomatio/skills](https://github.com/testomatio/skills) plus a built-in `analyze-tests` skill:
+A skill is a folder with a `SKILL.md`. The agent loads them all and invokes the ones a task calls for.
 
-| Skill                | Purpose                                  |
-| -------------------- | ---------------------------------------- |
-| analyze-tests        | Analyze test coverage, quality, and gaps |
-| generate-test-cases  | Create test cases from specs or code     |
-| find-duplicate-cases | Locate duplicate tests                   |
-| improve-test-cases   | Enhance existing test quality            |
-| reporter-setup       | Configure test reporters                 |
-| sync-cases           | Synchronize test cases with Testomat.io  |
+Every skill here is vendored from its own upstream repository, declared in `skills/skills.yaml` and pinned to a commit in `skills/skills.lock.json`. The vendored folders are deliberately **not** committed — they belong to their authors, under their own licences. A clone of this repository has the manifest and nothing else; the tree is fetched by the upstream release tooling, which is where the desktop app gets its full set.
 
-Update skills to latest:
-
-```bash
-npm update @testomatio/skills
-```
+The published `testeiya` package therefore ships no skills of its own: `skillsOverride` in `src/session.ts` keeps only what is found under the bundled tree, so a fresh `npx testeiya` run has none until that tree is filled. To add your own, point `additionalSkillPaths` at your folder — [EXTENDING.md](EXTENDING.md) covers both hooks. The first-party skills the desktop app bundles are written against tools only that harness has, so they live with it, in the private repository.
 
-## Architecture
+To propose a new source, add its line to `skills/skills.yaml` — see [CONTRIBUTING.md](CONTRIBUTING.md).
 
-Built on top of the [oh-my-pi coding-agent SDK](https://github.com/can1357/oh-my-pi) (a fork of [Pi](https://github.com/badlogic/pi-mono)):
+## Building your own agent
 
-- **`@oh-my-pi/pi-coding-agent`** - Agent session, tools (read/write/bash/grep/find), extensions
-- **`@oh-my-pi/pi-ai`** - Multi-provider LLM abstraction
-- **`@oh-my-pi/pi-tui`** - Markdown rendering
+The CLI is a thin composition over [pi](https://pi.dev): under 850 lines wiring the SDK to the prompt and skills here. A fork can add pi extensions and custom tools, or swap the one-shot run loop for pi's full interactive TUI — [EXTENDING.md](EXTENDING.md) walks through both.
 
-```
-src/
-  cli.ts              # Entry point
-  main.ts             # Bootstrap: config, auth, model, skills, session
-  config.ts           # Load testeiya.config.json
-  system-prompt.ts    # QA/testing system prompt
-  permissions.ts      # Read-allow / write-block permission gate
-  repl.ts             # Interactive REPL with markdown + paste support
-  skills/
-    analyze-tests.ts  # Built-in test analysis skill
-```
+## Contributing
 
-## Development
+Prompt wording is exactly what an outside contributor can improve, and a change to it changes how the agent behaves for everyone. Read [CONTRIBUTING.md](CONTRIBUTING.md) first — it covers what belongs here and what belongs upstream, in the repository that owns a given skill.
 
-```bash
-# Run directly (no build needed)
-bun src/cli.ts
+## Issues
 
-# Type-check
-npx tsc --noEmit
+This repository is also the public issue tracker for both surfaces:
 
-# Build for Node
-npm run build
-```
+- **Testeiya Desktop app** — the packaged desktop application
+- **Testeiya CLI** — the command-line agent in `src/`
 
-## License
+## Licence
 
-ISC
+[MIT](LICENSE).

package/dist/prompt/context.js

@@ -0,0 +1,79 @@
+import dedent from "dedent";
+import { TESTEIYA_DIR_NAME } from "./vocab.js";
+/** System-prompt section describing the workspace context; "" when none. */
+export function contextPromptSection(entries, folders = []) {
+    if (entries.length === 0 && folders.length === 0)
+        return "";
+    return dedent `
+  <workspace-context>
+    This workspace has context attached — the user (or you, earlier) put it there for a purpose. Consult it before answering, and prefer it over assumptions about the project.
+
+  ${contextLines(entries, folders)}
+
+    ALL of it lives under the hidden \`${TESTEIYA_DIR_NAME}/\` dir: file-search tools skip hidden dirs by default, so search it explicitly (pass hidden:true, or prefix the path with \`${TESTEIYA_DIR_NAME}/\`). Linked folders and cloned repositories are reference material: read them, never modify them. A linked folder is a symlink — wildcard searches do not descend into it; search it with its own path prefix (e.g. \`${TESTEIYA_DIR_NAME}/<name>/\`). Documents under \`${TESTEIYA_DIR_NAME}/requirements\` and \`${TESTEIYA_DIR_NAME}/docs\` are specs and plans — use them when writing or reviewing tests.
+  </workspace-context>
+  `;
+}
+/** Per-prompt notice when the context changed mid-session; appended to the next prompt. */
+export function contextUpdateNotice(entries, folders = []) {
+    if (entries.length === 0 && folders.length === 0) {
+        return dedent `
+    <workspace-context-update>
+      All extra workspace context was removed. Do not rely on it anymore.
+    </workspace-context-update>
+    `;
+    }
+    return dedent `
+  <workspace-context-update>
+    The workspace context just changed. It now contains:
+
+  ${contextLines(entries, folders)}
+
+    This was done for a purpose — take it into account for this and future requests. Remember \`${TESTEIYA_DIR_NAME}/\` is hidden: search it with hidden:true or an explicit path prefix.
+  </workspace-context-update>
+  `;
+}
+function contextLines(entries, folders) {
+    const lines = [];
+    const covered = new Set(entries.map((e) => parentDir(e.path)));
+    for (const f of folders) {
+        if (covered.has(f.path))
+            continue;
+        lines.push(`- \`${f.path}/\` — ${folderPurpose(f.name)}`);
+    }
+    for (const e of entries)
+        lines.push(`- ${describeEntry(e)}`);
+    return lines.join("\n");
+}
+function folderPurpose(name) {
+    if (name === "manual-tests") {
+        return "the project's manual test suites pulled from Testomat.io (*.test.md — THE manual tests of this project)";
+    }
+    if (name === "code")
+        return "reference code added as context";
+    if (name === "requirements")
+        return "requirements and specs";
+    if (name === "docs")
+        return "test planning and strategy documents";
+    if (name === "auto-tests")
+        return "automated test references";
+    return "exploratory testing setup";
+}
+function parentDir(rel) {
+    const idx = rel.lastIndexOf("/");
+    if (idx < 0)
+        return "";
+    return rel.slice(0, idx);
+}
+function describeEntry(e) {
+    const date = e.addedAt?.split("T")[0] ?? "";
+    let from = "";
+    if (e.origin && e.origin !== e.name)
+        from = ` from ${e.origin}`;
+    if (e.kind === "repo")
+        return `\`${e.path}\` — git repository${from} (${date})`;
+    if (e.kind === "folder")
+        return `\`${e.path}\` — local folder${from} (${date})`;
+    return `\`${e.path}\` — document${from} (${date})`;
+}
+//# sourceMappingURL=context.js.map

package/dist/prompt/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../prompt/context.ts"],"names":[],"mappings":"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"}

package/dist/prompt/index.js

@@ -0,0 +1,56 @@
+import { getSystemPrompt } from "./system-prompt.js";
+import { testomatioTms, testomatioConnection, testomatioNotConnected, projectSettings, } from "./testomatio.js";
+import { nonInteractive, reportOutput } from "./print.js";
+import { contextPromptSection, } from "./context.js";
+export function buildSystemPrompt(options) {
+    const mode = options?.mode ?? "tui";
+    const interactive = mode !== "print";
+    // The base prompt (role, workspace, tools, goals) comes first — it defines who
+    // the agent is. Specialized rules layer on after it, dynamic context goes last.
+    // Anything only one harness can do — its own question tool, a browser it can
+    // open for a watching user — reaches the prompt through `sections`,
+    // `toolBullets` and `rules`, never from here.
+    const parts = [
+        getSystemPrompt(options?.cwd, {
+            interactive,
+            toolBullets: options?.toolBullets,
+            rules: options?.rules,
+        }),
+    ];
+    const tokenSlugs = options?.tokens ? Object.keys(options.tokens) : [];
+    // The TUI passes no `connection`, so it keeps the managed-tokens gating.
+    const tokenAvailable = options?.connection?.tokenAvailable ?? tokenSlugs.length > 0;
+    const tms = options?.tms ?? "mcp-direct";
+    // Gated on the same condition as the connection section below: both describe
+    // the same connection, and the rules are just as needed when the token comes
+    // from the environment rather than from a per-project session token.
+    if (tokenAvailable || tokenSlugs.length > 0)
+        parts.push(testomatioTms(tms));
+    if (mode === "print")
+        parts.push(nonInteractive);
+    // Whatever this harness alone can offer — its chat-app UI tools, a browser it
+    // can open for a watching user. A one-shot CLI contributes none of it, and
+    // `nonInteractive` tells the agent to report such a gap rather than try.
+    for (const section of options?.sections ?? [])
+        parts.push(section);
+    if (options?.promptContext) {
+        parts.push(`## Project Test Context\n\n${options.promptContext}`);
+    }
+    if (options?.contextEntries?.length || options?.contextFolders?.length) {
+        parts.push(contextPromptSection(options.contextEntries ?? [], options.contextFolders ?? []));
+    }
+    if (options?.projectInfo) {
+        parts.push(projectSettings(options.projectInfo));
+    }
+    if (tokenAvailable || tokenSlugs.length > 0) {
+        parts.push(testomatioConnection(tokenSlugs, options?.backendUrl, options?.connection, tms));
+    }
+    else if (mode === "web" || mode === "print") {
+        parts.push(testomatioNotConnected());
+    }
+    // The report contract goes last so it is the final instruction the model reads.
+    if (options?.outputFile)
+        parts.push(reportOutput(options.outputFile));
+    return parts.join("\n\n");
+}
+//# sourceMappingURL=index.js.map

package/dist/prompt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../prompt/index.ts"],"names":[],"mappings":"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"}

package/dist/prompt/print.js

@@ -0,0 +1,22 @@
+import dedent from "dedent";
+export const nonInteractive = dedent `
+<non-interactive>
+  * Nobody is watching this session. There is no way to ask a question and no answer will ever come.
+  * Resolve every ambiguity yourself: pick the most reasonable reading and state the assumption in your output.
+  * Never wait for input, confirmation, or approval. Finish the whole task in this run.
+  * Missing credentials or an unreachable app are blockers, not questions — report them as the outcome.
+  * Do not launch or drive a browser. If the task needs one, report what it would take and stop.
+  * Call \`set_result\` with \`fail\` and a one-line reason when the verdict is negative: regressions found, a quality gate unmet, tests broken, or the task could not be completed. Otherwise do not call it — silence means success.
+</non-interactive>
+`;
+export function reportOutput(path) {
+    return dedent `
+<final-report>
+  * Write your complete final report to \`${path}\` with the \`write\` tool. Writing it is required before you finish.
+  * That file is your answer — it is the run's deliverable. Nothing else you say is kept.
+  * Markdown. Open with an \`#\` title, then the findings. Overwrite the file; never append.
+  * Keep your chat replies short: the report carries the detail.
+</final-report>
+`;
+}
+//# sourceMappingURL=print.js.map

package/dist/prompt/print.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"print.js","sourceRoot":"","sources":["../../prompt/print.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAA;;;;;;;;;CASnC,CAAC;AAEF,MAAM,UAAU,YAAY,CAAC,IAAY;IACvC,OAAO,MAAM,CAAA;;4CAE6B,IAAI;;;;;CAK/C,CAAC;AACF,CAAC"}

package/dist/prompt/project-info.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-info.js.map

package/dist/prompt/project-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-info.js","sourceRoot":"","sources":["../../prompt/project-info.ts"],"names":[],"mappings":""}

package/{src/prompt/system-prompt.ts → dist/prompt/system-prompt.js}

@@ -1,12 +1,17 @@
-import { tools } from './tools';
-import { TESTEIYA_DIR_NAME } from '../config.js';
-
+import { tools } from './tools.js';
+import { TESTEIYA_DIR_NAME } from './vocab.js';
 import dedent from 'dedent';
-
-export function getSystemPrompt(cwd?: string): string {
-  return dedent`
+export function getSystemPrompt(cwd, options) {
+    const interactive = options?.interactive ?? true;
+    let missingSecretAction = "STOP and ask the user to provide it";
+    if (!interactive)
+        missingSecretAction = "report it as a blocker in your output";
+    let extraRules = "";
+    for (const rule of options?.rules ?? [])
+        extraRules += `    * ${rule}\n`;
+    return dedent `
   <role>
-    You are Testeiya, an interactive AI agent that helps with QA tasks.
+    You are Testeiya, an AI agent that helps with QA tasks.
     You assist in transforming code and requirements into maintainable testing strategies.
     Your power is in skillset available to you which allows to build a comprehensive QA strategy.
   </role>
@@ -16,14 +21,13 @@ export function getSystemPrompt(cwd?: string): string {
     Workspace can contain source code, e2e tests, or just manual tests. You must understand yourself what is inside workspace.
 
     * Workspace is ${cwd || process.cwd()} - Exclude system folders like \`.git/\`, \`src/\` from analysis and modification.
-    * **Filesystem First:** Scan local files (\`ls\`, \`grep\`, \`read\`) before invoking any MCP tools.
-    * RULE OF THUMB: IF YOU NEED ADDITOINAL CONTEXT STORE IT TO \`${TESTEIYA_DIR_NAME}\` directory.
+    * RULE OF THUMB: IF YOU NEED ADDITIONAL CONTEXT STORE IT TO \`${TESTEIYA_DIR_NAME}\` directory.
       * **Working Storage:** All persistent QA metadata must live in \`${TESTEIYA_DIR_NAME}\` in root.
       * **Safety root:** Never add \`${TESTEIYA_DIR_NAME}\` to the repo's \`.gitignore\` — it excludes itself, and a repo-level entry hides it from your search tools.
     * **System Access:** You have read/write access to all files in \`${TESTEIYA_DIR_NAME}\` directory and its subdirectories.
     * **Hidden dir:** \`${TESTEIYA_DIR_NAME}\` is a dot-folder — file-search tools skip it by default. Search it with hidden:true or an explicit \`${TESTEIYA_DIR_NAME}/\` path prefix. Pulled manual tests usually live in \`${TESTEIYA_DIR_NAME}/manual-tests/\` — check there before declaring the project has no manual tests.
 
-    * If the workspace is application source code, do never change it, use it for discovery. Save your data into \`${TESTEIYA_DIR_NAME}\` context directory.
+    * If the workspace is application source code, do never change it, use it for discovery. Save what you keep into \`${TESTEIYA_DIR_NAME}\` context directory.
     * If the workspace is e2e tests directory you can write tests for it. All additional context
     * If the workspace is empty you can store manual test cases in .test.md format into the workspace itself.
 
@@ -31,10 +35,11 @@ export function getSystemPrompt(cwd?: string): string {
     * \`${TESTEIYA_DIR_NAME}\` Context Structure:
       - \`<name>/\`: a linked or cloned external project, named after its source (read-only reference).
       - \`requirements/\`: User stories and acceptance criteria (pdfs, docs, images, etc).
-      - \`docs/\`: Feature explanations, test planing and strategy files.
+      - \`docs/\`: Feature explanations, test planing and strategy files — prose for humans, never data dumps.
       - \`manual-tests/\`: Markdown-based test cases
       - \`auto-tests/\`: Relevant automated (e2e) tests
       - \`exploratory/\`: For explorbot setup
+    * **Session scratch:** everything you make to answer *this* request — the one-off scripts you write and run, their output, intermediate dumps and joins — goes to the scratch dir named in your context — a system temp dir when none is named — never into the workspace. It is wiped with the session. Only the context listed above earns a place in \`${TESTEIYA_DIR_NAME}\`.
     * When user needs an external Git repository or local path, clone or symlink it to \`${TESTEIYA_DIR_NAME}/<name>\` (the source's basename; \`extra-\` prefix if taken). Wildcard searches do not descend into symlinks — search a linked dir with its own \`${TESTEIYA_DIR_NAME}/<name>/\` path prefix.
     * Directory is empty or contains mostly \`.test.md\` files and we are in manual test mode => write test cases into workspace
     * If directory is not empty, treat it as a regular workspace and use \`${TESTEIYA_DIR_NAME}\` context directory for external files.
@@ -80,7 +85,7 @@ export function getSystemPrompt(cwd?: string): string {
 
   * ${new Date().toISOString().split("T")[0]} - Current Date (use for time-sensitive decisions, e.g., "recently modified files").
 
-  ${tools}
+  ${tools({ extra: options?.toolBullets })}
 
   <goals>
     You help in variety of tasks related to software testing, including writing test cases, analyzing test results, and providing feedback.
@@ -90,7 +95,7 @@ export function getSystemPrompt(cwd?: string): string {
 
     * Writing & managing manual test cases
     * Writing and debugging automated tests for api, browser & mobile
-    * Assiting user to execute manual tests (using browser and scripts)
+    * Assisting with manual test execution
     * Manage tests with TMS Testomat.io
     * Setting up CI pipelines for continuous testing
     * Analyzing requirements
@@ -102,11 +107,10 @@ export function getSystemPrompt(cwd?: string): string {
   </goals>
 
   <communication-style>
-    * **Lead with intent:** Before any multi-step or long-running task, open with one short plain-text paragraph — short sentences — telling the user what you are about to do and your plan. State the main idea up front. This is visible output, not thinking, and not a Plan widget. Then start working.
+    * **Lead with intent:** Before any multi-step or long-running task, open with one short plain-text paragraph — short sentences — telling the user what you are about to do and your plan. State the main idea up front. This is visible output, not thinking. Then start working.
     * **Technical (QA-aware):** Prefer standard QA terms and jargon: E2E (end-to-end), regression, test coverage, assertion, etc.
     * Prefer to use tables, bullet points, and concise prose over long paragraphs.
-    * Data/analysis answers follow the \`answer-formatting\` skill.
-    * Be helpful, be curious, and always ask for clarification when needed.
+    * Be helpful and curious. ${interactive ? "Ask for clarification when a choice is genuinely the user's to make." : "Nobody is available to answer, so decide yourself and state the assumption."}
   </communication-style>
 
   <output-efficiency>
@@ -125,10 +129,9 @@ export function getSystemPrompt(cwd?: string): string {
 
   <rules>
     * **Verification Required:** Never report tests as passing, implemented, working, or done without actually running them and seeing a scenario execute. A run that errors before any test executes (missing env var, build/compile/init failure, app unreachable) is **blocked, not done** — surface that as the headline, never as a footnote under a success summary.
-    * **Investigate Before You Write:** Before writing UI/browser automation, open the target page/feature in a live browser and read its real DOM (selectors, texts, URLs). Never invent selectors from a manual test, a description, or a different page. If you cannot open a browser, say so and base locators strictly on existing page objects/tests, marking unverified ones.
-    * **Ask for Missing Secrets:** If running a test is blocked by a missing credential/env var/secret in the project under test, STOP and ask the user to provide it — you cannot fabricate or assume a secret. (This is distinct from the pre-configured Testomat.io token, which is always available.)
-    * **Testomat.io Questions Go Through the Docs:** For any question about the Testomat.io platform — how a feature works, test management, runs and execution, reporting, the web interface, or a product term you cannot define with certainty — use the \`testomatio-docs\` skill and answer from the documentation, never from memory. Remember Testeiya is a client to that platform: every documented feature works, but the interface the docs describe is the **web app's**, not this one — send interface answers to the user's Testomat.io host, and prefer performing the action via MCP or \`check-tests\` over telling the user where to click.
-    * **Zero Assumptions:** Do not assume test frameworks exist; verify via discovery tools.
+${extraRules}    * **Missing Secrets:** If running a test is blocked by a missing credential/env var/secret in the project under test, ${missingSecretAction} — you cannot fabricate or assume a secret. (This is distinct from the pre-configured Testomat.io token, which is always available.)
+    * **No Tool Covers It, Say So:** When nothing you have can answer the question, name what is missing and ask — via \`ask_question\` when available. Never substitute a search you can run for the question you were asked, and never end a turn with nothing.
+    * **Verify Facts, Don't Guess Them:** Never assume a framework, file, or config exists — confirm it with discovery tools. This governs facts you can check, not judgement calls, which you still make yourself.
     * **Environment Isolation:** Never hardcode credentials or environment-specific paths.
     * **No Implicit Structure:** Do not invent files, folders, or configurations that do not exist; verify before use.
     * **Metadata Source of Truth:** All testing metadata must exist only in \`${TESTEIYA_DIR_NAME}/\`:
@@ -137,7 +140,6 @@ export function getSystemPrompt(cwd?: string): string {
   </rules>
   `;
 }
-
 /*
 TODO:
 1) Remove "guidelines" from system prompt and extend it with more detailed instructions:
@@ -159,3 +161,4 @@ Where it runs - On the first agent run, Testeiya bootstraps the workspace (defau
 (Bootstrapping always runs on the gateway host. If the macOS app connects to a remote Gateway, the workspace and bootstrapping
 files live on that remote machine).
 */
+//# sourceMappingURL=system-prompt.js.map

package/dist/prompt/system-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.js","sourceRoot":"","sources":["../../prompt/system-prompt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B,MAAM,UAAU,eAAe,CAAC,GAAY,EAAE,OAAuB;IACnE,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,IAAI,CAAC;IACjD,IAAI,mBAAmB,GAAG,qCAAqC,CAAC;IAChE,IAAI,CAAC,WAAW;QAAE,mBAAmB,GAAG,uCAAuC,CAAC;IAChF,IAAI,UAAU,GAAG,EAAE,CAAC;IACpB,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE,KAAK,IAAI,EAAE;QAAE,UAAU,IAAI,SAAS,IAAI,IAAI,CAAC;IACzE,OAAO,MAAM,CAAA;;;;;;;;;;;qBAWM,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE;oEAC2B,iBAAiB;yEACZ,iBAAiB;uCACnD,iBAAiB;wEACgB,iBAAiB;0BAC/D,iBAAiB,0GAA0G,iBAAiB,0DAA0D,iBAAiB;;yHAExH,iBAAiB;;;;2CAI/F,iBAAiB;UAClD,iBAAiB;;;;;;;gWAOqU,iBAAiB;2FACtR,iBAAiB,sJAAsJ,iBAAiB;;6EAEtM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyCxF,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;;IAExC,KAAK,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;gCAyBV,WAAW,CAAC,CAAC,CAAC,sEAAsE,CAAC,CAAC,CAAC,6EAA6E;;;;;;;;;;;;;;;;;;;EAmBlM,UAAU,6HAA6H,mBAAmB;;;;;gFAK5E,iBAAiB;;;;GAI9F,CAAC;AACJ,CAAC;AAWD;;;;;;;;;;;;;;;;;;;;EAoBE"}