# simplify3x-connect (npm · simplify3x-connect)

SimplifyQA test management: find, author, record, run and triage test cases.

- Trust score: 68/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `simplify3x-connect`: 68/100 (this document), [markdown](https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect.md), [page](https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect)

## Channel facts

- Registry: `npm`
- Package: `simplify3x-connect`
- Version: `0.31.9`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 36 of 110 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 1 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 58/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 48136 tokens (~425/item across 113 items; 113 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 13/100
  - Stability observed for 4 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 94/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 83% of tool parameters carry a description.
- **Tool Safety**: 98/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - 15 of 16 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "suite_remove_testcases" implies "remove" and declares no destructiveHint at all, which the MCP spec reads as destructive by default.
  - An AI judge read all 114 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the simplify3x-connect MCP server?

simplify3x-connect runs locally as an npm package, launched with npx -y simplify3x-connect. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-simplifyqa-simplify3x-connect -- npx -y simplify3x-connect
```

### Cursor

```json
{
  "mcpServers": {
    "com-simplifyqa-simplify3x-connect": {
      "command": "npx",
      "args": [
        "-y",
        "simplify3x-connect"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-simplifyqa-simplify3x-connect": {
      "command": "npx",
      "args": [
        "-y",
        "simplify3x-connect"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-simplifyqa-simplify3x-connect -- npx -y simplify3x-connect
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-simplifyqa-simplify3x-connect": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "simplify3x-connect"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-simplifyqa-simplify3x-connect --command npx --arg -y --arg simplify3x-connect
```

### Hermes

```yaml
mcp_servers:
  com-simplifyqa-simplify3x-connect:
    command: "npx"
    args: ["-y", "simplify3x-connect"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-simplifyqa-simplify3x-connect": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "simplify3x-connect"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-simplifyqa-simplify3x-connect -t stdio -c npx -a -y simplify3x-connect
```

### Other

```json
{
  "mcpServers": {
    "com-simplifyqa-simplify3x-connect": {
      "command": "npx",
      "args": [
        "-y",
        "simplify3x-connect"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-20 (score 68, +1)

- [security regression] Stability: 0.07 → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 0.31.3 → 0.31.9

### 2026-11-19 (score 67, +26)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.85
- [functional] Package version: 0.31.2 → 0.31.3

### 2026-11-18 (score 41, −25)

- [security regression] Malware scan: pass → unverified
- [security regression] Known CVEs: pass → unverified
- [functional regression] Schema quality: 36396 → 44804
- [functional regression] Schema quality: 36396 → 44644
- [functional regression] Dependency health: 0.85 → unverified
- [functional improvement] Destructive annotations: 77% → 93%
- [functional improvement] Stability: unverified → 0.03
- [functional] Package version: 0.28.1 → 0.31.2
- [functional] Package version: 0.28.1 → 0.31.1

### 2026-11-17 (score 66)

First indexed and scored.

## MCP tools (113)

### `project_info` (~22 tokens)

Check the connection and project

Validate the configured connection and return provider, org/project and entity counts.

### `qa_connect` (~436 tokens)

Connect to a QA product

Point this MCP at your QA product so it can work with EXISTING test cases -- list them, read their steps, modify them, and run them. Ask the user for their app URL and a token; do not guess either. The token is a product session JWT (then `projectId` is required, because the token alone carries no project context) or an MCP API key (then pass auth:"key" and projectId is optional -- a key is already project-scoped).

The connection is VALIDATED before it is accepted (it fetches the project), so a wrong URL, token or project fails here with the reason rather than surfacing later as a confusing error, and a failed attempt leaves any working connection untouched. It is kept in memory for as long as the agent runs and is never written to disk or logged.

NOT needed to record a new test case: recording, the live editor and drafts work offline with nothing configured.

Input parameters:

- `auth` (string): Token kind. Omit to AUTO-DETECT from the token (JWT-shaped → "jwt"). "jwt" sends Authorization + x-project-id; "key" sends Authorization only.
- `baseUrl` (string): The product BACKEND REST base (QA_BASE_URL) for DIRECT data ops (list/read/save/run). Provide this for a direct connection; `url` is only needed for recording / save-with-editor.
- `product` (string): Which product to route this connection to (the product selector; defaults to the primary product). For a remote product, also pass its agent MCP `/mcp` endpoint as `url`.
- `projectId` (string): Project id. REQUIRED with a JWT; optional with an API key.
- `token` (string, required): Bearer token: a product session JWT, or an MCP API key.
- `url` (string): MCP endpoint to hop to — the product agent /mcp, used for recording and save-with-editor. OPTIONAL for a DIRECT (backend-REST) connection: pass `baseUrl` instead. Required when connecting through a r…

### `qa_switch_project` (~131 tokens)

Switch the connected project

Switch to a different project on the SAME connection — reuses the current URL + token, so you do NOT re-enter them. Pass the project id; if the user names a project, resolve the name to an id first (SimplifyQA: sqa_query collection "projects" with member:true; Walnut: list_projects). Validated before it is adopted, so a bad id leaves the current project in place.

Input parameters:

- `projectId` (string, required): The project id to switch to. Find it by name with sqa_query collection "projects" (SimplifyQA) or list_projects (Walnut).

### `qa_connection_status` (~81 tokens)

Show the current connection

Report whether this MCP is connected to a QA product, which URL and project, how the credentials arrived (startup config vs qa_connect), and whether a token is present. Also reports whether the LOCAL desktop agent (/mcp, default :4040) is reachable — the process that actually runs LOCAL executions on this machine. The token value itself is never returned.

### `qa_disconnect` (~55 tokens)

Drop the connection

Forget the runtime URL and token and fall back to whatever the agent started with (usually nothing). Use it before connecting to a different app or project, or to stop this MCP reaching a backend at all. Offline authoring is unaffected.

### `actions_catalog` (~121 tokens)

List the offline action-type catalog

Static per-platform action-type vocabulary (web/android/ios/api/database/mainframe), used for offline draft validation. No network call. NOTE mainframe is deliberately EMPTY (no source list exists), and validate.ts skips validation entirely for an empty catalog — so a clean mainframe draft means "not checked", not "checked and fine".

Input parameters:

- `platform` (string): desktop: there is no offline list; on SimplifyQA the live catalog includes the DESKTOP actions (dsk-*: Launch Application, Click, Type Text, Switch to Window by Name, …).

### `tc_draft_from_tc` (~282 tokens)

Load an existing test case as a draft for in-place editing

Fetch a REAL test case from the connected product and hydrate it into a draft, carrying the original tcId. Because the draft carries the id, a later `tc_save({ draftId })` UPDATES that SAME test case (preserving id, run history, parameters, testdata bindings, and suite membership) instead of creating a sibling.

THIS is the tool for "tag/retag this EXISTING test case with a user story or module" — `journal_modify`'s `set_meta` does NOT support that on SimplifyQA (journal-only ops there), so this draft round-trip is the only path:
  1\. tc_draft_from_tc({ tcId })
  2\. tc_draft_update({ draftId, ops: [{ op: "set_meta", patch: { storyRef?, folderOrModule?, title?, priority?, ... } }] }) — resolve a story/module NAME to an id via story_list / list_modules FIRST; never guess one.
  3\. tc_save({ draftId })
Same three steps also apply to applying a `story_sync_testcases` drift report (pass the filtered `proposedOps` at step 2 instead of a set_meta patch). Requires a live connection (qa_connect).

Input parameters:

- `tcId` (string, required): The existing test-case id to load as a draft.

### `tc_draft_from_journal` (~195 tokens)

Load a recording journal as an automation draft

Load the steps from a recording session (the journal on the connected agent) into a new AUTOMATION draft. Use this to save a recording that finished — including one from an earlier session. Then review with tc_draft_get and persist with tc_save. If the recording targeted an existing TC, pass its id via `tcId` so the draft inherits title/module/project and tc_save UPDATES that TC instead of creating a new one. Requires a live connection (qa_connect) with an agent that owns the recording journal.

Input parameters:

- `sessionId` (string, required): The recording session id — the same id used when the recording started.
- `tcId` (string): Optional: an existing TC id to inherit title/module/project from (and to UPDATE on save).
- `title` (string): Optional draft title (overrides tcId meta). Defaults to "Recording <sessionId>" when no tcId is passed.

### `tc_draft_create` (~897 tokens)

Create a test-case draft

MANUAL-ONLY authoring. Call this when the user asked for a MANUAL test case: they said "manual", "draft only", "plain prose", "no automation", or asked to cover a user story's acceptance criteria as manual cases. For those, this IS the right tool — call it.

Do NOT use for automated tests. "create a test case", "record this flow", "add a test for X" (with no "manual" qualifier) mean AUTOMATED — route to the `web` / `mainframe` sub-agent to RECORD with real locators instead.

Create a new in-memory test-case draft from steps you author yourself. Nothing is persisted -- no disk, no backend, no network. Use tc_draft_open to hand it to the test-case editor for viewing.

DO NOT USE THIS FOR A REAL WEB APPLICATION. Steps written here have no locators, so the test case cannot execute -- it only reads plausibly. Whenever there is an app you can reach (the user gives a URL, names an environment, or asks for a test of a real flow), call the `web` sub-agent instead: that captures real locators, real element names and real parameters, and is the DEFAULT way to create a web test case. You do not need the user to say "record" -- if a test case for a real app is wanted, recording is how it is made.

Legitimate uses: a MANUAL test case the user explicitly asked for (no automation), API/database steps that need no element binding, restructuring or drafting steps the user supplied verbatim, or sketching a plan when no app is reachable -- and say plainly that the result is not executable until recorded.

PARAMETERISE EVERY DYNAMIC VALUE — this is mandatory for manual test cases whenever the step names a URL, credential, product name, form value, expected string, or anything the tester will type / compare. Instead of hard-coding "Enter admin in the Username field", write "Enter ${username} in the Username field" and pass `data: { username: "admin" }` at the TC level. Every `${name}` token becomes a Local parameter in the product and the value from `data` populates the test case's defa…

Input parameters:

- `category` (string)
- `data` (object): Default values for the `${name}` tokens in step descriptions — one entry per token. Populates the auto-created default test-data row (ITR-1) on save. Example: `{ username: "admin", password: "admin12…
- `description` (string): Optional test-case description / summary.
- `executionPlatform` (object): SimplifyQA-only, ANDROID/IOS only: the device the test case targets — { id: <device serial>, name, technologyType: "ANDROID"|"IOS", type: "REAL_DEVICE"|"CLOUD_DEVICE" }. The backend rejects a mobile…
- `folderOrModule` (string): SimplifyQA-only: id of the MODULE / folder to file this test case under on save (from list_modules). ASK the user which module before drafting; SimplifyQA files test cases in a module tree. Walnut ig…
- `priority` (string)
- `steps` (array)
- `storyRef` (string): Link this test case to a USER STORY — its id or business key (US_123, from story_list / story_get). Used when drafting MANUAL test cases for a story so they save linked to it.
- `technologyType` (string): SimplifyQA-only: the test case's TECHNOLOGY (the form's Type) — WEB | API | ANDROID | IOS | DATABASE | MAINFRAME | DESKTOP | SAP. Applies to MANUAL test cases too (a manual Desktop/Android/iOS/API ca…
- `title` (string, required)

### `tc_draft_update` (~587 tokens)

Update a test-case draft

Apply one or more ops (set_meta | add_step | update_step | remove_step | move_step | duplicate_step) to a draft. Steps renumber contiguously from 1 after every op.

To COPY a step ("add the same step 2 at the end") use duplicate_step { n, at? } — never rebuild it with add_step: duplicate_step clones the WHOLE step (parameters and their values, object, flags, browser, API request, settings) so nothing is lost. For an IF / loop / function block pass `through` too (the last step of the block).

update_steps { where, patch } applies ONE patch to EVERY step matching `where` (numbers, from/to, stepType, actionType, object, descriptionContains, parameter) — use it for "skip every step that uses X"; an empty `where` is refused unless all:true. To change WHICH parameter a step uses, put `swapParams: [{ from, to, value? }]` in the step patch (it replaces the parameter in the SAME slot; `recordedParam` only adds). To edit a project parameter itself (Local <-> Runtime, default value) use parameter_update.
To change an API step IN PLACE (add an assertion, change the URL / a header / the body) use update_step with `patch.api`: it is MERGED into the saved request, so only what you pass changes. `api.addAssertions: [{ path, condition, expectedValue }]` appends assertions (e.g. path "statusCode", "$.body.id", "$.headers.X"); `api.assertions` replaces the whole list. NEVER remove_step + add_step to edit a step — that deletes it and creates a different one.

STEP TYPE — for add_step / update_step on a MANUAL test case (tc.category === "manual", or every existing step arrived with stepType "manual"), pass `stepType: "manual"`. For an AUTOMATED test case pick the execution technology ("web", "api", "android", …). Getting this wrong routes the row to the wrong UI card and it renders blank in the desktop viewer.

CALLING A SAVED FUNCTION — a function step is `{ stepType: "function", actionType: "function", description, functionCall: { testCaseId: "FN-12" } }` (the numeric id also works).…

Input parameters:

- `draftId` (string, required)
- `ops` (array, required)

### `tc_draft_get` (~37 tokens)

Get a test-case draft

Fetch a draft by id: readable steps table, validation summary, and the neutral TestCase.

Input parameters:

- `draftId` (string, required)

### `tc_draft_discard` (~38 tokens)

Discard a test-case draft

Delete an in-memory draft. Nothing was ever persisted, so there is nothing else to undo.

Input parameters:

- `draftId` (string, required)

### `tc_draft_open` (~85 tokens)

Open a draft in the test-case editor

Show this draft in the product's real editor. Prefers the local agent's own native window when the agent is running; otherwise returns a link to open. The draft rides in the URL fragment -- nothing is uploaded, no backend call is made.

Input parameters:

- `draftId` (string, required)
- `frontendOrigin` (string)
- `useAgentWindow` (boolean)

### `tc_edit_open` (~401 tokens)

Open an existing test case for live prompt-driven step editing

One-shot: hydrate an EXISTING test case as a draft, open it in the desktop TC-viewer window, and bind a live-edit session so subsequent tc_draft_update calls stream the changes into the window in real time (TC_EDIT_RESYNC on each op batch, per plan/tc-edit-live-protocol.md). ⚠️ THIS OPENS THE DESKTOP RECORDER/VIEWER WINDOW (scrcpy / SCRPY). Use it ONLY when the user explicitly wants to WATCH the edits live or asks to open the test case in the viewer. For a plain prompt like "add a step to TC N at step 3", "remove step 2", "change step 3" do NOT use it — call journal_modify({ tcId, ops:[{ op:"add_step", at, step }] }), which edits the saved test case directly with no window.

Returns { draftId, sessionId, tcId }. Follow up with tc_draft_update({ draftId, ops }) for edits and tc_save({ draftId }) to persist. Requires a live connection (qa_connect); the desktop app must be running on the same machine or the window-open call silently no-ops (the draft still mutates correctly — only the live view is lost).

Input parameters:

- `accessToken` (string): Bearer token forwarded to the desktop window for API calls.
- `baseUrl` (string): sqa-ui origin (defaults to whatever the desktop app is configured with).
- `hashRoute` (string): Optional Angular hash route override, e.g. "#/user/testcase/details/593". Defaults to "#/user/testcase/details/<numericTcId>" (matches the browser UI route). Pass this only if the product's testcase-…
- `projectId` (string|number)
- `tcId` (string, required): The existing test-case id to open for editing.
- `userId` (string|number)

### `tc_record_append` (~277 tokens)

Record additional steps into a TC that is already open in the editor

Start a live-browser recording session whose captured steps stream into the tc-viewer window bound by an earlier `tc_edit_open`. Each user interaction becomes a TC_EDIT_INSERT event in the editor. Returns instructions the model must follow (this tool itself does not touch the driver):
  1\. `core_activate_technology({ technology:"WEB", mcpTcEditSessionId, testcaseName })` — starts      the browser and binds captures to this window. The response `structuredContent.sessionId` is      the RECORDING session id — remember it for step 3.
  2\. Use `web_*` tools to drive the browser. Every captured step shows up live in the editor.
  3\. When done, `tc_record_stop({ draftId, recordingSessionId })` reads the recording journal      and appends the captured steps to the draft. Then `tc_save({ draftId })` to persist.

A DESKTOP test case gets a desktop guide instead: technology "DESKTOP", `desktop_launch_application({ app_path })` first, then `desktop_snapshot` + `desktop_*` verbs.

The draft must have been opened via `tc_edit_open` first — its stored sessionId is what binds the recorder to the correct window.

Input parameters:

- `draftId` (string, required): The draft id from tc_edit_open.

### `tc_record_stop` (~172 tokens)

Append recorded steps to the draft after tc_record_append

Read the recording journal for a session and add each captured step to the draft as an `add_step` op. Pairs with `tc_record_append`. Follow with `tc_save({ draftId })` to persist.

CAVEAT: The recording journal is process-scoped and may contain steps from earlier recordings in the same Java-server process. Pass `fromIndex` to skip the first N steps if the journal accumulated prior state — usually the count of steps recorded before `tc_record_append` was called.

Input parameters:

- `draftId` (string, required)
- `fromIndex` (integer): Optional: skip the first N steps in the journal (defaults to 0 = take all).
- `recordingSessionId` (string, required): The session id from `core_activate_technology`'s response.structuredContent.sessionId.

### `tc_suggest_functions` (~291 tokens)

Suggest existing functions for the recorded steps

Call this RIGHT AFTER a recording finishes (before asking the user to save). It compares the recorded steps with the project's existing reusable functions and returns the groups of steps that already exist as a function. If it returns matches, show them to the user and ASK which function(s) to replace (all / some / none) — do not decide for them. Read-only: nothing changes. Pass EXACTLY ONE of `sessionId` (live/finished recording), `draftId`, or `tcId` (already saved).

Input parameters:

- `draftId` (string): A draft id.
- `minConfidence` (string): For tcId only. 'exact' (default) = same action/element AND the same parameter names; 'strong' also accepts the same action/element with a different parameter set (a re-parameterised copy of the flow).
- `sessionId` (string): Recording session id (core_activate_technology / core_active_recordings).
- `tcId` (string): A saved test case id or business key. Matched on step IDs (actionId/objectId/stepType/technologyType + parameter names), not on display names.
- `versionId` (string): For tcId only: which version's steps to match (an id from the TC's versions[]). Omit for the TC's currently-selected version; on a multi-version TC ASK the user first.

### `tc_suggest_function_groups` (~300 tokens)

Suggest functions for the steps just recorded (create + replace)

THE post-recording step: call this as soon as a recording finishes and BEFORE asking the user to save. It returns BOTH kinds of suggestion in one answer: `replace` — blocks of recorded steps that already exist as a reusable function (offer to swap them for a call to that function), and `create` — contiguous blocks that are good candidates for a NEW reusable function (offer to extract them). Read-only: nothing is created, replaced or saved. Show both lists and ASK the user per block: create as a new function (ask for the name) / replace with the existing FN-x / keep as recorded. Apply AFTER the test case is saved (tc_steps_to_function with replaceInSource:true, or tc_replace_with_functions). Pass EXACTLY ONE of `sessionId` (a finished recording), `draftId`, or `tcId` (already saved).

Input parameters:

- `draftId` (string): A draft id (tc_draft_from_journal / tc_draft_from_tc / tc_draft_create).
- `groupSize` (integer): Target steps per proposed new function. Default 6, minimum 3.
- `sessionId` (string): Recording session id (core_activate_technology / core_active_recordings).
- `tcId` (string): A saved test case id or business key.
- `versionId` (string): For tcId only: which version to analyse (an id from the TC versions[]).

### `tc_replace_with_functions` (~223 tokens)

Replace steps of a SAVED test case with existing functions

After the user has chosen (from tc_suggest_functions) which functions to use, swap the matching steps of an already-saved test case for a call to each chosen function. Use this when the user saved from the recorder window; if the recording is not saved yet, pass the choice to tc_save instead. `functionIds` = the user's picks; omit for all matches. The replaced steps' own testdata is dropped and the function's default iterations are used. ONLY call after the user said yes.

Input parameters:

- `functionIds` (array): Function ids to apply (from tc_suggest_functions). Omit = all matches.
- `replace` (array): Explicit picks: replace exactly these seqs with these functions, skipping the matcher. Takes precedence over functionIds. This is the "use FN-12 for steps 3-6" path.
- `tcId` (string, required): Saved test case id or business key.
- `versionId` (string): Version to edit (an id from the TC versions[]). Omit for the current version.

### `tc_save` (~647 tokens)

Save a draft or a live recording

Persist a test case to the connected product. Pass EXACTLY ONE of:
  • `draftId` — validate and save a draft (create, or update when the draft carries an id).
  • `sessionId` — save a LIVE/RECENT recording by asking the /mcp-recorder window to click its OWN Save button. This is the exact-parity path: the recorder editor saves the steps, objects, parameters, control flow, functions, API popup values and title/module/story that the user is looking at, including edits made in the window. The recorder window must be open; it stays open for review after saving. Returns the created test case id + deep link.
Requires a live connection (qa_connect).
EXCEPTION — API recordings: after the LAST `api_send_request`, call this ONCE with the sessionId WITHOUT asking, so the recorded API test case is persisted and searchable immediately (the user must not have to click Send and Save first). Only once per recording; never per request.
⚠️ OTHERWISE CALL ONLY ON AN EXPLICIT USER SAVE INSTRUCTION (e.g. "save it", "save this", "persist it"). RECORDING or AUTHORING a test case is NOT a save instruction; neither is the user approving the content ("looks good", "nice"). After a recording/draft finishes, SHOW the steps and ASK — do NOT auto-save. When unsure whether a reply meant save, ASK rather than saving. Never save a recording TWICE (UI Save + tc_save): if the user already clicked Save in the recorder, treat it as done.

Input parameters:

- `allowDuplicate` (boolean): Set true ONLY after the user confirms they want a new test case with the same name as an existing one. Default: a new test case whose name already exists is saved as name_1, name_2, ….
- `copyTestdataFrom` (string): Optional source TC id (or TC code). After the recording is saved, copy that TC's default-iteration testdata onto the new test case, matching parameters BY NAME. Use this when converting a manual TC (…
- `draftId` (string): Draft id from tc_draft_create / tc_draft_open. Omit when saving a live recording.
- `replaceWithFunctions`: Function reuse. Before saving, the steps are compared with the project's existing functions. If some already exist as a function and this is OMITTED, the tool does NOT save — it returns the matches a…
- `sessionId` (string): Recording session id from core_activate_technology (or core_active_recordings). Saves via the recorder window's own Save button.

### `tc_automate` (~259 tokens)

Turn a manual test case into a recording guide (creates a NEW automated TC)

Read an EXISTING MANUAL test case and return a recording guide the model uses to drive a live recording via the connected agent's granular tools (web_launch_application, web_snapshot, web_click, web_enter_text, …, core_close_session). The Electron recorder window opens automatically on web_launch_application; each captured step streams into it. The user reviews and clicks Save in the recorder — that CREATES A NEW automated test case (via POST /tm/testcase); the source manual TC is left untouched. Pass `url` unless the manual steps already contain one, and `extra` for credentials / data / what to assert. Read-only from MCP: this tool composes text, it never writes. Requires a live connection.

Input parameters:

- `app_path` (string): DESKTOP test cases only (tcType DESKTOP): the full path of the application's .exe. A DESKTOP test case needs no `url`; its guide uses the desktop_* tools.
- `extra` (string): Extra guidance for the recording: credentials, data, assertions.
- `tcId` (string, required): The manual test case id (or business key TC_123) to automate.
- `url` (string): Starting URL for the recording (the app under test).

### `tc_delete` (~134 tokens)

Delete a test case (two-step confirm)

Soft-delete an existing test case in the connected product. TWO-STEP CONFIRM: call once with just `tcId` to preview the target (title + step count) and get a warning; then call again with `{ tcId, confirm: true }` to actually delete. Refuses to delete without `confirm:true`. `tcId` accepts the product's id or business key. Requires a live connection (qa_connect). Product-neutral.

Input parameters:

- `confirm` (boolean): Set to true on the SECOND call to actually delete.
- `tcId` (string, required): The test case id (or business key) to delete.

### `tc_clone` (~486 tokens)

Save a test case as a new test case (same project + module)

FOR TEST CASES ONLY. NOT for reusable functions: if the user names an `FN_*` key or asks to clone a function, use `fn_clone` instead. Trigger words for THIS tool: "test case", "TC", "TC_", "scenario", "script".

Save an existing test case as a NEW test case (new TC id) in the SAME project + module. Mirrors the FE in-editor "Save as new TC" dialog (operation: SAVEASNEWTC). Clones ONE source version — pass `sourceVersionId` to pick which; defaults to the TC's currently selected version. `tcId` accepts the numeric id or business key (`TC_*`).

\`newName` is REQUIRED — backend rejects an empty name on SAVEASNEWTC.

TESTDATA — TWO-STEP: call once WITHOUT `tdCopy` to get the "Copy Test Data" prompt and confirm with the user; then call again with `tdCopy` set. Mirrors the FE's "COPY TEST DATA" modal (Cancel = false, Confirm = true). The tool REFUSES to clone until `tdCopy` is passed — the prompt step is not skippable.

\`tdCopy:true` clones the source version's testdata iterations across every environment. `tdCopy:false` copies only the column STRUCTURE — one empty iteration (`ITR-1`) per environment; cells fall back to each parameter's project-level `defaultValue` if any.

Requires a live connection.

Input parameters:

- `newName` (string, required): Name for the new test case (required by backend).
- `sourceVersionId` (string): Which version of the source TC to clone; defaults to the TC's current version.
- `sourceVersionName` (string): Version to use, by NAME/number as the user says it (e.g. "v2", "2"). Preferred over sourceVersionId — the user should never need an id. If the source has several versions and this is omitted, the too…
- `tcId` (string, required): The source test case id or business key (e.g. TC_123).
- `tdCopy` (boolean): REQUIRED to actually clone. Whether to clone the source version's testdata iterations. Omit on the first call to get the confirmation prompt; ask the user, then call again with the chosen value.

### `tc_save_as_new_version` (~604 tokens)

Snapshot a test case as a new version

FOR TEST CASES ONLY. NOT for reusable functions: if the user names an `FN_*` key or asks to snapshot / create a new version of a function, use `fn_save_as_new_version` instead. Trigger words for THIS tool: "test case", "TC", "TC_", "scenario", "script".

Freeze the CURRENT server state of a test case under a NEW version name — same TC id, a new version row with cloned steps. Mirrors the SimplifyQA UI "Save as new version" dialog (operation: SAVENEWVERSION). `tcId` accepts the numeric id or business key (`TC_*`).

\`versionName` must be unique for this TC — the backend rejects duplicates.

TESTDATA — TWO-STEP: call once WITHOUT `tdCopy` to get the "Copy Test Data" prompt and confirm with the user; then call again with `tdCopy` set. Mirrors the FE's "COPY TEST DATA" modal (Cancel = false, Confirm = true). The tool REFUSES to snapshot until `tdCopy` is passed — the prompt step is not skippable.

\`tdCopy:true` clones the source version's testdata iterations across every environment. `tdCopy:false` copies only the column STRUCTURE — one empty iteration (`ITR-1`) per environment; cells fall back to each parameter's project-level `defaultValue` if any.

\`sourceVersionId` picks which version to snapshot; omit to snapshot the TC's currently selected version. Requires a live connection.

Input parameters:

- `fromDraftId` (string): Freeze THIS edited draft as the new version instead of the stored state — the "update + save as new version" path. Load it first with tc_draft_from_tc({tcId}) (+ tc_draft_update), then pass its draft…
- `sourceVersionId` (string): Version to snapshot; defaults to the TC's current version.
- `sourceVersionName` (string): Version to use, by NAME/number as the user says it (e.g. "v2", "2"). Preferred over sourceVersionId — the user should never need an id. If the source has several versions and this is omitted, the too…
- `tcId` (string, required): The test case id or business key (e.g. TC_123).
- `tdCopy` (boolean): REQUIRED to actually snapshot. Clone testdata iterations from the source version. Omit on the first call to get the confirmation prompt; ask the user, then call again with the chosen value.
- `versionName` (string): Name for the new version. OMIT to auto-increment (v1.0 → v2.0 → v3.0 …) from the versions already on the TC — the normal path for an update. If given it must be unique for this TC.

### `tc_steps_to_function` (~893 tokens)

Extract selected steps of a test case into a new reusable function

Take a subset of the steps on an EXISTING test case and save them as a new reusable function (SimplifyQA STEPSTOFN operation). Mirrors the FE "Save as function" modal. Steps are picked by their current `seq`, resequenced 1..N in the new function, and filed under `moduleId`. `tcId` accepts the numeric id or business key (TC_123). Requires a live connection (qa_connect).

CALL THIS when the user says things like "save these steps as a function", "convert the first N steps to a function", "extract these steps into a function". Show the steps of the TC first (via tc_get) so the user can confirm which `seq`s to extract, and ASK the user which module to file the new function under — call `list_modules` if the module id is not known.

VERSIONS: SimplifyQA TCs can have multiple versions with DIFFERENT step counts/content. When the TC has more than one version and `versionId` is omitted, this tool REFUSES and lists the available versions — ASK the user which version's steps to convert, read that version's steps with tc_get({ id, versionId }) to confirm the `seq`s, then call this tool again with the SAME `versionId`. Pass `versionId: ''` to accept the TC's currently-selected version without prompting. Single-version TCs are used directly.

\`executionType` forces every picked step into the AUTOMATION or MANUAL bucket; omit to split by each step's own executionType (function will be DUO if both are present).

TESTDATA: iterations from the source TC version are copied to the new function by default. The backend prunes them to only the parameters the extracted steps reference (via key-based matching in tcfn.service.js `compareDatas` `isStepsToFn` mode), across every environment the source version has. Pass `copyTestData: false` if you explicitly want a bare function.

REPLACE-IN-SOURCE: pass `replaceInSource: true` to also splice a FUNCTION + FUNCTION_END pair back into the source TC in place of the extracted steps (mirrors the FE "Save & Replace" button). The extracted rows are…

Input parameters:

- `copyTestData` (boolean): Copy the source version's testdata iterations to the new function (backend prunes to only the params the extracted steps use). Default: true.
- `executionType` (string): Force all picked steps into this bucket; omit to split by each step's own executionType.
- `moduleId` (integer, required): Module id to file the new function under. Resolve via list_modules if unknown.
- `name` (string, required): Name for the new function.
- `replaceInSource` (boolean): Replace the extracted steps on the source TC with a FUNCTION + FUNCTION_END call to the new function. Default: false (create-only). Requires contiguous stepSeqs and refuses DUO/SYNCON/control-flow sp…
- `stepSeqs` (array, required): Current `seq` numbers of the steps to extract (e.g. [1,2,3,4] for the first four). Must be contiguous when replaceInSource is true.
- `tcId` (string, required): The source test case id or business key (e.g. TC_123).
- `versionId` (string): Version to extract steps FROM — an id from the TC's `versions[]`, from a real tc_get read the user directed. REQUIRED whenever the TC has more than one version (this tool refuses when it's omitted OR…

### `delete_function` (~200 tokens)

Delete a reusable function (NOT a test case; two-step confirm)

Soft-delete a reusable FUNCTION in the connected product. NOT for test cases: if the user asks to delete a TC or TC_* id, use `tc_delete` instead. Trigger words for THIS tool: "function", "FN_", "reusable function". TWO-STEP CONFIRM: call once with just `id` to preview the target (name + step count) and get a warning; then call again with `{ id, confirm: true }` to actually delete. Refuses to delete without `confirm:true`. `id` accepts the function's numeric id or business key. The backend refuses to delete a function that is still referenced by a test case, another function, or a workflow — this tool surfaces those references so the user can remove them first.

Input parameters:

- `confirm` (boolean): Set to true on the SECOND call to actually delete.
- `id` (string, required): The function id (or business key like FN_123) to delete.

### `fn_clone` (~487 tokens)

Save a reusable function as a new function (same project + module)

FOR REUSABLE FUNCTIONS ONLY. NOT for test cases: if the user names a `TC_*` key or asks to clone a test case / scenario / script, use `tc_clone` instead. Trigger words for THIS tool: "function", "reusable function", "FN_", "FN-".

Save an existing reusable FUNCTION as a NEW function (new FN id) in the SAME project + module. Mirrors the FE in-editor "Save as new function" dialog (operation: SAVEASNEWFN). Clones ONE source version — pass `sourceVersionId` to pick which; defaults to the FN's newest version. `fnId` accepts the numeric id or business key (`FN_*`).

\`newName` is REQUIRED — backend rejects an empty name on SAVEASNEWFN.

TESTDATA — TWO-STEP: call once WITHOUT `tdCopy` to get the "Copy Test Data" prompt and confirm with the user; then call again with `tdCopy` set. Mirrors the FE's "COPY TEST DATA" modal (Cancel = false, Confirm = true). The tool REFUSES to clone until `tdCopy` is passed — the prompt step is not skippable.

\`tdCopy:true` clones the source version's testdata iterations across every environment. `tdCopy:false` copies only the column STRUCTURE — one empty iteration (`ITR-1`) per environment; cells fall back to each parameter's project-level `defaultValue` if any.

Requires a live connection.

Input parameters:

- `fnId` (string, required): The source function id or business key (e.g. FN_123).
- `newName` (string, required): Name for the new function (required by backend).
- `sourceVersionId` (string): Which version of the source FN to clone; defaults to the FN's newest version.
- `sourceVersionName` (string): Version to use, by NAME/number as the user says it (e.g. "v2", "2"). Preferred over sourceVersionId — the user should never need an id. If the source has several versions and this is omitted, the too…
- `tdCopy` (boolean): REQUIRED to actually clone. Whether to clone the source version's testdata iterations. Omit on the first call to get the confirmation prompt; ask the user, then call again with the chosen value.

### `fn_save_as_new_version` (~505 tokens)

Snapshot a reusable function as a new version

FOR REUSABLE FUNCTIONS ONLY. NOT for test cases: if the user names a `TC_*` key or asks to snapshot / create a new version of a test case, use `tc_save_as_new_version` instead. Trigger words for THIS tool: "function", "reusable function", "FN_", "FN-".

Freeze the CURRENT server state of a reusable FUNCTION under a NEW version name — same FN id, a new version row with cloned steps. Mirrors the SimplifyQA UI "Save as new version" dialog (operation: SAVENEWVERSION, type: FN). `fnId` accepts the numeric id or business key (`FN_*`).

\`versionName` must be unique for this FN — the backend rejects duplicates.

TESTDATA — TWO-STEP: call once WITHOUT `tdCopy` to get the "Copy Test Data" prompt and confirm with the user; then call again with `tdCopy` set. Mirrors the FE's "COPY TEST DATA" modal (Cancel = false, Confirm = true). The tool REFUSES to snapshot until `tdCopy` is passed — the prompt step is not skippable.

\`tdCopy:true` clones the source version's testdata iterations across every environment. `tdCopy:false` copies only the column STRUCTURE — one empty iteration (`ITR-1`) per environment; cells fall back to each parameter's project-level `defaultValue` if any.

\`sourceVersionId` picks which version to snapshot; omit to snapshot the FN's newest version (the FN doc has no inline current-version marker). Requires a live connection.

Input parameters:

- `fnId` (string, required): The function id or business key (e.g. FN_123).
- `sourceVersionId` (string): Version to snapshot; defaults to the FN's newest version.
- `sourceVersionName` (string): Version to use, by NAME/number as the user says it (e.g. "v2", "2"). Preferred over sourceVersionId — the user should never need an id. If the source has several versions and this is omitted, the too…
- `tdCopy` (boolean): REQUIRED to actually snapshot. Clone testdata iterations from the source version. Omit on the first call to get the confirmation prompt; ask the user, then call again with the chosen value.
- `versionName` (string, required): Name for the new version (must be unique for this FN).

### `create_module` (~274 tokens)

Create a module (folder), optionally with a nested subtree, in the test-case tree

Create a new MODULE under the connected project. Set `isRoot:true` for a top-level folder; otherwise pass `parentId` (resolve via list_modules). To create a WHOLE HIERARCHY in one call (root + submodules + nested submodules), pass a `children` array — each child gets `isRoot:false` and its parentId auto-wired from the tree position (do NOT set `isRoot`/`parentId` on child nodes). Duplicate name in the same project is rejected server-side. On mid-subtree failure the response carries `failedAt`; every node before it is already persisted (no transactional rollback upstream). SimplifyQA-only. Requires a live connection.

Input parameters:

- `children` (array): Optional subtree under this module. Each child = { name, description?, children? } — no isRoot/parentId (derived).
- `description` (string): Free-text description.
- `isRoot` (boolean, required): True → top-level folder; false → child of `parentId`.
- `name` (string, required): Module name. Must be unique within the project.
- `parentId` (string): Parent module id (required when isRoot is false; MUST be omitted when isRoot is true).
- `projectId` (string, required): Target project id (see list_projects).

### `update_module` (~216 tokens)

Update a module (rename / edit description / move parent)

Edit an existing MODULE — pass `id` plus any of `name`, `description`, `parentId`. Name must remain unique within the project (duplicate rejected server-side). Works regardless of whether test cases/functions/etc. are tagged to the module — no need to delete and recreate it to rename or move it. `parentId` moves the module elsewhere in the tree (pass `""` to move it to project root); moving it under itself or under one of its own descendants is refused. SimplifyQA-only. Requires a live connection.

Input parameters:

- `description` (string): New description (pass "" to clear).
- `id` (string, required): Module id (numeric or business key, e.g. MO_12).
- `name` (string): New module name.
- `parentId` (string): New parent module id (from list_modules). Moves this module in the hierarchy. Pass "" to move it to project root instead of under another module.
- `projectId` (string): Project id; defaults to the connected project.

### `delete_module` (~154 tokens)

Delete modules (with dependency dry-run)

Delete one or more MODULES by id. Two phases: call with `confirm:false` (default) for a DRY RUN that returns each id's dependency footprint (test cases, functions, parameters, objects, defects, user stories that still reference the module). Call again with `confirm:true` to actually delete; the server drops only ids with EMPTY dependencies and silently skips the rest — surface those to the caller so they can move/remove the refs first. SimplifyQA-only. Requires a live connection.

Input parameters:

- `confirm` (boolean): False (default) → dry-run; true → apply delete.
- `ids` (array, required): Module ids to delete.
- `projectId` (string, required): Project id the modules belong to.

### `delete_version` (~369 tokens)

Delete a version of a test case or function (two-step confirm)

Soft-delete ONE version of a test case (`kind:"tc"`) or a reusable function (`kind:"fn"`) in the connected product. `versionId` comes from the parent's `versions[]` (populated by `tc_get` for TCs and `get_function` for FNs); pass the version's `name` too (backend validator requires it). TWO-STEP CONFIRM: call once with `confirm:false` (default) to get a DRY RUN — the response lists every entity still referencing this version (defects, suites, exec plans, scenarios, schedulers, pipelines, workflows for a TC; TCs, other FNs, workflows for a FN). Only when EVERY dependency map is empty is the delete allowed; the server itself REFUSES a `confirm:true` call when refs still exist, so `confirm:true` doesn't guarantee deletion — the tool inspects the response and reports honestly. Refuses to delete the LAST remaining version (the parent would be orphaned; use `tc_delete` / `delete_function` instead to remove the whole entity). SimplifyQA-only. Requires a live connection.

Input parameters:

- `confirm` (boolean): False (default) → dry-run; true → apply delete (server still refuses if any dependency exists).
- `kind` (string, required): 'tc' for a test-case version; 'fn' for a function version.
- `parentId` (string, required): Parent TC or FN id (numeric or business key like TC_123 / FN_45).
- `versionId` (string, required): The version's uuid (from tc_get.versions[].id or get_function.versions[].id).
- `versionName` (string, required): The version's human name (e.g. 'v1.0'). Required by the backend validator.

### `suite_create` (~252 tokens)

Create a new suite from a few test cases

Create a NEW test suite in the connected project from a small set of existing test cases. `tcIds` accepts numeric ids, business keys (TC_123), OR plain test case NAMES — a name is resolved by searching the project (tc_list under the hood); an ambiguous name (multiple matches) or one with zero matches is reported back rather than guessed. NOTE: a suite can only hold test cases of ONE category (all manual OR all automated) — a mixed set is refused.

NAME: if `name` is omitted, this tool does NOT create anything yet — it resolves the test cases, SUGGESTS a suite name, and returns a preview. Show the user the suggested name and the resolved test cases, ask them to confirm it or give their own, then call suite_create again with `name` set (and the same `tcIds`) to actually create it. Requires a live connection.

Input parameters:

- `description` (string): Optional suite description.
- `name` (string): Suite name. Omit to get a suggested name + preview first (does not create).
- `tcIds` (array, required): Test case ids, business keys (TC_123), or plain names to include.

### `suite_add_testcases` (~251 tokens)

Add test cases to a suite (optionally a specific VERSION of each)

Add one or more EXISTING test cases to a suite (appended in order). `tcIds` takes ids or business keys (e.g. TC_123); use suite_list / tc_list to find them. To pin a VERSION, pass `testCases:[{ tcId:"TC-12826", version:"v2.0" }]` (or `versionId`) — the same test case can sit in the suite once per version (v1.0 and v2.0 are two rows). A requested version that does not exist is an ERROR (nothing is added twice as v1.0). Default = the test case's current version; an (tc, version) pair already in the suite is skipped. NOTE: a suite can only hold test cases of ONE category (all manual OR all automated) — the product rejects a mix. Returns the updated suite.

Input parameters:

- `suiteId` (string, required): The suite id to add to (from suite_list).
- `tcIds` (array): Test case ids / business keys to add (their current version).
- `testCases` (array): Test cases with an explicit version — lets one TC be added once per version.

### `suite_remove_testcases` (~88 tokens)

Remove test cases from a suite

Remove one or more test cases from a suite. `tcIds` accepts ids or business keys; every occurrence of each is removed and the remaining test cases are reordered. Requires a live connection. Returns the updated suite with its test cases.

Input parameters:

- `suiteId` (string, required): The suite id to remove from.
- `tcIds` (array, required): Test case ids / business keys to remove.

### `journal_modify` (~898 tokens)

Modify a test case (steps, loops, if-else, nested)

Apply granular edits to an EXISTING test case and persist them, opening the result in the test-case editor. Use journal_grep first to see the numbered steps, then pass ops (numbers are from that view, 1-based):
  • add_step / update_step / remove_step / move_step — edit individual steps
  • duplicate_step { n, through?, at? } — copy the WHOLE step (parameters, values, object, flags, settings) to the end or to `at`; use this for "add the same step again", not add_step. `through` is required when n opens an IF / loop / function block.
  • update_steps { where, patch } — one patch for EVERY matching step ("skip every step that uses X"); where: numbers, from/to, stepType, actionType, object, descriptionContains, parameter, or all:true
  • a step patch may carry swapParams [{ from, to, value? }] to replace one parameter with another in the same slot (recordedParam only adds)
  • add_assertions { n, assertions:[{ path, condition, expectedValue }] } — APPEND response assertions to an EXISTING API step (path: statusCode | responseTime | responseSize | $.body.x | $.headers.Name). The request, object, action, parameters and existing assertions are untouched — use this for "add only the assertion to step N".
  • update_step patch.api is MERGED into the saved API request (add an assertion: api.addAssertions [{ path, condition, expectedValue }]; api.assertions replaces the list) — edit an API step with this, never remove_step + add_step
  • wrap_in_loop { from, to, condition?, maxIterations? } — wrap steps from..to in a while loop
  • wrap_in_if   { from, to, condition? } — wrap steps from..to in an if block
  • add_step with stepType "control_flow" and controlFlow { kind, condition } — kind "while" … "end_while" (WHILE), "do" … "end_do_while" (DO-WHILE; the condition goes on the closing step). Conditions: controlFlow.condition = { type: element_displayed | element_not_displayed | element_enabled | element_disabled | element_clickable | element_checked, objectId | objectName },…

Input parameters:

- `ops` (array, required): Ops to apply, in order.
- `tcId` (string, required): Test case id or business key.
- `versionId` (string): SimplifyQA, multi-version test cases: the version to edit — its id or name (e.g. "v2.0"); step numbers are that version's (read it with journal_grep { versionId }). Omit to edit the CURRENT version.…

### `sqa_query` (~1138 tokens)

Query any SimplifyQA collection (catalog / search / get / related / custom_fields)

THE ONLY READ TOOL ON SIMPLIFYQA. Use it for EVERY fetch / query / list / search / get / read / count request. The old per-collection read tools (tc_list, tc_get, story_list, story_get, epic_list, feature_list, list_modules, list_functions, suite_list, list_users, object_list, defect_list, task_list, list_releases, list_sprints, journal_grep, ...) are NOT registered on a SimplifyQA connection — do not look for them and do not invent one.

FLOW: (1) `op:"catalog"` (optionally with a collection) to see descriptions/fields/relations, (2) `op:"search"` for a list or `op:"get"` for one row, (3) `op:"related"` to follow a FK (story → testcases, testcase → defects, suite → runs, module → testcases, ...). For "how many" use `op:"count"` (same `where`), and add `groupBy` for a breakdown ("defects by severity").

RULES: every search injects `deleted:false` and the active project; deleted rows are never returned. Unknown fields/operators are rejected locally (the backend silently returns 0 rows for unknown columns). `priority`/`status` do NOT exist on SimplifyQA test cases — use `reviewApproveStatus` or a custom field.

CUSTOM FIELDS: `op:"custom_fields"` returns label → key → `customFields.<key>`; then pass the label as `field` with `custom:true` in `where` (or resolve one with `name`).

EXAMPLES:
\- "list API test cases in module 46" → `{ op:"search", collection:"testcases", where:[{field:"tcType",op:"eq",value:"API"},{field:"moduleId",op:"eq",value:46}] }`
\- "defects for TC 684" → `{ op:"related", collection:"testcases", id:"684", relation:"defects" }`
\- "latest run of suite 120 + steps" → `{ op:"search", collection:"executions", where:[{field:"executionTypeId",op:"eq",value:120},{field:"type",op:"eq",value:"SUITE"}], sort:[{field:"id",dir:"desc"}], limit:1 }` then `{ op:"get", collection:"executions", id:"<runId>" }`
\- "testcases where SEVERITY is High" → `{ op:"search", collection:"testcases", where:[{field:"SEVERITY",custom:true,op:"contains",value:"High"}] }`
\- "release…

Input parameters:

- `allProjects` (boolean): releases / sprints / epics / features, op:"search" or "count": read across EVERY project you have a role in instead of only the active one (no qa_switch_project needed). A projectId/projectIds filter…
- `allVersions` (boolean): Stories/epics: return every version row instead of one row per item.
- `collection` (string): Collection name or alias (testcases, tc, stories, defects, executions, ...). Required except for catalog.
- `dryRun` (boolean): Return the compiled searchFields payload without calling the backend.
- `expand` (array): For op:"get": relation names to expand (e.g. ["steps","versions"]).
- `groupBy` (string): For op:"count": the field to break the count down by (e.g. "state", "severity", "ownerId", "tcType").
- `id` (string): Row id/business key — required for op:"get" and op:"related".
- `includeHidden` (boolean): Include rows hidden by default (obsolete test cases; child runs and re-execution copies of executions). Naming the field in `where` does the same.
- `limit` (integer): Page size (default 50, max 500).
- `name` (string): For op:"custom_fields": optional label/key to resolve (omit to list all).
- `offset` (integer): Row offset (not a page number — the engine sets skipStartIndex).
- `op` (string, required): Operation to run. "count" returns how many rows match (with `groupBy`, per value).
- `relation` (string): Relation name from the catalog — required for op:"related".
- `select` (array): Fields to return. Use ["*"] for the full row. Defaults to the collection summary projection.
- `sort` (array): Sort fields. Example: [{ field:"id", dir:"desc" }].
- `versionId` (string): For op:"get"/"related" on testcases/functions: the version whose steps to read.
- `where` (array): Filters, an ARRAY of { field, op?, value }. Combined with AND unless a filter sets condition:"or". Example: [{ field:"name", op:"contains", value:"login" }].

### `qa_privileges` (~281 tokens)

Check what you may create in a project

READ-ONLY preflight for recording: resolves the role the connected user holds in a project and that role's privilege keys, then says whether recording is allowed there. Answers the three failure modes BEFORE anything is created: invalid/expired token, no role in the project, or a role missing a write the recorder needs (add_testcase / add_parameter / add_object, plus mobile/mainframe/cloud integration keys for those technologies).

Returns verdict ok | no-role | missing-privileges | invalid-token, the role name, the full privilege list, a `can` summary, and the exact keys to ask an admin for. The product agent runs the same check inside core_activate_technology, so you never need to call this first — call it when you want to warn the user, or to explain a refusal.

Input parameters:

- `need` (array): Extra privilege keys to verify, e.g. ["add_userstory"].
- `projectId` (string): Project to check. Defaults to the selected project.
- `provider` (string): Device provider for ANDROID/IOS (local|emulator|simplifyqa|lambdatest|browserstack|saucelabs) — cloud providers also need allow_cloud_integration.
- `technology` (string): Check the extra privileges this recording technology needs (mobile/mainframe integration keys). Default: WEB.

### `object_create` (~197 tokens)

Create a new object in the Object Repository

Create a new object (a locator-bound UI element) in the shared Object Repository. `objectType` (e.g. "WEB", "ANDROID") is REQUIRED and STRUCTURAL — it selects the object template and cannot be changed after creation (see object_update). `locators` is the set of captured selector strategies for this element. GET-OR-CREATE by NAME (case-insensitive): if an object with the same name already exists, this reuses it — updating its locators in place if they differ — instead of creating a duplicate. Requires a live connection (qa_connect).

Input parameters:

- `locators` (array): Captured locator strategies for this element.
- `name` (string, required): Display name for the object (the UI's "Name" column).
- `objectType` (string, required): Object type / technology, e.g. "WEB", "ANDROID", "IOS", "DESKTOP". Required, and fixed once created.

### `parameter_update` (~215 tokens)

Edit a project parameter (Local / Runtime, default value, description)

Edit a PARAMETER itself in the project - not a step's use of it. Typical: "make task_doc a Runtime parameter" (a store slot written by a Read action must be Runtime), or change its default value / description. Local <-> Runtime only: Global parameters are encrypted and shared and are not edited here.

IMPACT: the change applies to EVERY test case that uses this parameter. So the call is a preview until you pass `confirm: true` - show the user what will change and that it affects every use, then call again with confirm. The parameter is re-read after the update and the call REFUSES if the change did not take. Requires a live connection.

Input parameters:

- `confirm` (boolean): Must be true to apply. Without it the call only describes what would change.
- `defaultValue` (string)
- `description` (string)
- `parameter` (string, required): The parameter's exact name (case-insensitive) or numeric id.
- `type` (string): New access type.

### `object_update` (~634 tokens)

Update an object (name, description, parameter, module, or locators)

Update an object in the shared Object Repository — rename it, change its description, set which parameter(s) it is bound to, move it to a different module, and/or fix locator values directly (e.g. a stale `data-test` attribute). Any combination of these can be set in ONE call when the user states them together. `locators` UPSERTS by strategy name: an entry matching an EXISTING locator name updates its value/unique in place, everything else on the object is untouched, and a name with no existing match is added as a NEW locator — you do not need to resupply the full locator set.

DEFAULT LOCATOR: to make a locator the object's DEFAULT (the one the UI marks as default and the executor uses first — "make it default"), pass `defaultLocator: "<locator name>"`, e.g. add an xpath with `locators: [{ name: "xpath", value: "//input[@id='u']" }]` AND `defaultLocator: "xpath"` in one call. It can also name a locator already on the object (no need to resend its value). Only one default exists — it is cleared on the others. The result is re-read and the call REFUSES if the default did not take.

\`parameterNames` REPLACES the object's full parameter binding with these (resolved by exact name, case-insensitive) — pass the CURRENT set plus the new one if the user means "also bind" rather than "replace"; read the object first (object_get) if you need to know the current bindings. `moduleName` takes the module's NAME, never an id — it is resolved automatically. Both REFUSE clearly (naming the bad value and the valid options) if the name doesn't match anything, rather than silently saving nothing.

The object's TYPE (technology) and TEMPLATE ID are NOT editable here — they are structural (they determine which attribute set is even valid) and stay whatever they already are; changing either means creating a new object, not updating this one. Requires a live connection (qa_connect).

Input parameters:

- `defaultLocator` (string): NAME of the locator to make the object's DEFAULT, e.g. "xpath" — one you add in `locators` in this same call, or one already on the object. Use this whenever the user says "make it default".
- `description` (string): New description for the object.
- `id` (string, required): The object id to update.
- `locators` (array): Locators to upsert by name, e.g. [{ name: "data-test", value: "123456" }] to fix one attribute — every other locator on the object is left as-is.
- `moduleName` (string): Move the object to this module, by NAME (resolved automatically — never pass an id).
- `name` (string): New display name for the object.
- `parameterNames` (array): REPLACES the object's bound parameters with these, resolved by exact name (case-insensitive). Pass the full desired set, not just the one being added.

### `object_delete` (~227 tokens)

Delete an object from the Object Repository (two-step confirm)

Delete an object from the shared Object Repository. TWO-STEP CONFIRM, REQUIRED even for a single object: call once with just `id` to preview it (name/type + how many test cases, functions, or workflows still reference it); then call again with `{ id, confirm: true }` to actually delete. NEVER call this with confirm:true on the first call, and NEVER call it at all unless the user's own words asked to DELETE — a request to list, show, or read objects (object_list / object_get / "show me the objects in this test case") is NEVER a reason to call this tool. DEPENDENCY-CHECKED: if the object is still referenced by any test case, function, or workflow, the delete is REFUSED at confirm time too — it reports what still uses it instead of silently breaking those. Requires a live connection (qa_connect).

Input parameters:

- `confirm` (boolean): Set to true on the SECOND call to actually delete. Omit (or false) to preview first.
- `id` (string, required): The object id to delete.

### `story_sync_testcases` (~1024 tokens)

Sync a user story with its manual AND automation test cases (drift + recording plan)

Compare a user STORY against every test case linked to it (via storyRef) and return a structured, ORDERED plan for bringing them up to date.

MANUAL test cases → textual drift (ac_added / ac_reworded / ac_removed / step_stale) and the exact draft ops (add_step / update_step / remove_step).
AUTOMATION test cases → `action: "rerecord"` (or `"up-to-date"`) plus the recording brief: the acceptance criteria to cover, story/module ids, current steps and testdata seeds. An automated TC cannot be re-texted — it must be re-recorded.

HOW TO APPLY (one item at a time, in plan order — never in parallel):
  MANUAL item:
    1. tc_draft_from_tc({ tcId })
    2. tc_draft_update({ draftId, ops: item.proposedOps })
    3. tc_save_as_new_version({ tcId, fromDraftId: draftId })   ← new version (v1.0 → v2.0)
  OBSOLETE item (action === "obsolete") — the scenario this TC tested was REMOVED from the story
    and NO step matches any current AC:
    ASK the user, then journal_modify({ tcId, ops: [{ op: "set_meta", patch: { obsolete: true } }] }).
    Do NOT strip its steps (that leaves an empty, still-active TC) and do NOT delete it.
  PARTIAL removal — only SOME steps belonged to the removed scenario:
    item.proposedOps carries ONE bulk remove_steps { numbers:[11,12,13,14,15] }; apply the MANUAL
    item steps 1-3 above. The result is a NEW VERSION without those steps (v1.0 keeps them).
    NEVER obsolete a partially-affected TC.
  AUTOMATION item (action === "rerecord"):
    1. ASK the user AI-only or Hybrid, then
       core_activate_technology({ technology, testcaseId: item.testCaseId, versionName: item.nextVersionName, testcaseName: item.title, userstoryId: item.brief.userstoryId, moduleId: item.brief.moduleId, recordingMode, recordingModeAskedUser })
       The recorder window opens on THAT test case (details + versions, steps cleared) and
       shows the pending version in the version dropdown (v1.0 → v2.0, v2.0 → v3.0).
    2. Record the brief.acceptanceCriteria end-to-end (w…

Input parameters:

- `includeTestData` (boolean): Include the automation brief's testdata seeds (default true; costs one extra read per automation TC). Set false for a fast check.
- `scanLimit` (integer): Cap on how many TCs to fetch when `testCaseIds` is omitted. Default 200.
- `scope` (string): Which linked test cases to plan for. Default "both" (manual drift + automation re-record plan).
- `sensitivity` (string): Match-strictness for AC↔step overlap. strict=more drift flagged, loose=less. Default normal.
- `storyId` (string, required): Story id or business key (US_123).
- `testCaseIds` (array): Restrict comparison to these TC ids/keys. Recommended for large projects; otherwise the tool walks up to `scanLimit` TCs.
- `versionStrategy` (string): How a MANUAL update is written: "new" (default) = new version (v1.0 → v2.0) preserving history; "in-place" = overwrite the current version.

### `epic_create` (~868 tokens)

Create an epic

Create a new EPIC in the connected project. `projectIds` defaults to the current project when omitted. `state` defaults to the project-configured default state when omitted; pass it only when overriding (must match an existing state in the project config — see epic_list / epic_get). Backend requires `name`, `estimatedEffort`, `plannedStartDate`, `plannedEndDate`. **`description` must be a DETAILED epic write-up as HTML (NOT markdown) derived from the source document (BRD, spec, user request). SQA UI renders this via a Tiptap editor and stores raw HTML — see the description field docstring for the exact allowed tags and required section structure. One-line summaries are not acceptable.** `customFields` may be omitted — an empty object is sent automatically.

Input parameters:

- `actualEffort` (number)
- `actualEndDate` (string)
- `actualStartDate` (string)
- `customFields` (object): Optional. Empty object `{}` sent automatically when omitted.
- `description` (string): REQUIRED-QUALITY: rich HTML write-up sourced from the BRD/spec. NOT markdown — the SQA UI  renders this through a Tiptap editor and stores the raw HTML string. Minimum 300 words when  a BRD is availa…
- `estimatedEffort` (number, required): Estimated effort (hours).
- `name` (string, required): Epic name (3–500 chars).
- `ownerId` (number): Numeric userId of the epic owner.
- `plannedBudget` (number)
- `plannedEndDate` (string, required): ISO date/datetime for planned end.
- `plannedStartDate` (string, required): ISO date/datetime for planned start.
- `projectIds` (array): Project ids the epic belongs to. Defaults to [currentProject].
- `remainingEffort` (number)
- `state` (string): Optional. Defaults to the project-configured default epic state when omitted.
- `tags` (array)
- `teamId` (array)
- `watchList` (array): Watch List (the UI email button): emails, full names or numeric userIds to receive notifications. Applied after creation.

### `epic_update` (~226 tokens)

Update an epic (partial)

PATCH an existing EPIC — pass only the fields to change plus `updateVersion` (optimistic concurrency, from the last epic_get). Accepts id or business key (EP_123). Cannot rename the epic to a duplicate of another epic in the same customer.

Input parameters:

- `actualEffort` (number)
- `actualEndDate` (string)
- `actualStartDate` (string)
- `customFields` (object)
- `description` (string)
- `estimatedEffort` (number)
- `id` (string, required): Epic id or business key (EP_123).
- `name` (string)
- `ownerId` (number)
- `plannedBudget` (number)
- `plannedEndDate` (string)
- `plannedStartDate` (string)
- `projectIds` (array)
- `remainingEffort` (number)
- `state` (string)
- `tags` (array)
- `teamId` (array)
- `updateVersion` (number): Optimistic-concurrency version from the last read.

### `feature_create` (~981 tokens)

Create a feature

Create a new FEATURE. `projectIds` defaults to the current project when omitted.

\**HIERARCHY — ALWAYS RESOLVE BEFORE CALLING.** Features live under Epics. Before calling this tool, confirm with the user which `epicId` this feature belongs to. If the user has not told you: (1) ask them directly, or (2) if they name an epic, resolve the id via `epic_list`. When creating MULTIPLE features from a BRD, group them under the correct epic — do not scatter them. Skip epic linking only if the user explicitly says "no epic" or "standalone feature".

\`state` and `priority` default to the project-configured defaults when omitted; pass them only when overriding. Backend requires `name`, `estimatedEffort`, `plannedStartDate`, `plannedEndDate`. **`description` must be a DETAILED feature write-up as HTML (NOT markdown) — SQA UI renders it via a Tiptap editor. See the description field docstring for the exact allowed tags and required section structure. One-line summaries are not acceptable.** `customFields` may be omitted — an empty object is sent automatically.

Input parameters:

- `actualEffort` (number)
- `actualEndDate` (string)
- `actualStartDate` (string)
- `customFields` (object): Optional. Empty object `{}` sent automatically when omitted.
- `description` (string): REQUIRED-QUALITY: rich HTML write-up sourced from the BRD/spec. NOT markdown — the SQA UI  renders through a Tiptap editor and stores raw HTML. Minimum 250 words when the BRD covers  this feature; NE…
- `epicId` (number): Parent epic numeric id. RESOLVE VIA `epic_list` OR ASK THE USER before creating — do not leave a feature parent-less unless the user explicitly says "no epic".
- `estimatedEffort` (number, required)
- `name` (string, required)
- `orphan` (boolean): Set true ONLY if the user has explicitly said the feature has no parent epic ("standalone", "no epic"). Required when `epicId` is omitted — the tool refuses otherwise.
- `ownerId` (number)
- `plannedEndDate` (string, required)
- `plannedStartDate` (string, required)
- `priority` (string): Optional. Defaults to the project-configured default feature priority when omitted.
- `projectIds` (array)
- `remainingEffort` (number)
- `state` (string): Optional. Defaults to the project-configured default feature state when omitted.
- `tags` (array)
- `teamId` (array)
- `watchList` (array): Watch List (the UI email button): emails, full names or numeric userIds to receive notifications. Applied after creation.

### `feature_update` (~208 tokens)

Update a feature (partial)

PATCH an existing FEATURE — pass only the fields to change plus `updateVersion` (optimistic concurrency, from the last feature_get). Accepts id or business key (FT_123).

Input parameters:

- `actualEffort` (number)
- `actualEndDate` (string)
- `actualStartDate` (string)
- `customFields` (object)
- `description` (string)
- `epicId` (number)
- `estimatedEffort` (number)
- `id` (string, required): Feature id or business key (FT_123).
- `name` (string)
- `ownerId` (number)
- `plannedEndDate` (string)
- `plannedStartDate` (string)
- `priority` (string)
- `projectIds` (array)
- `remainingEffort` (number)
- `state` (string)
- `tags` (array)
- `teamId` (array)
- `updateVersion` (number)

### `story_create` (~1306 tokens)

Create a user story

Create a new USER STORY under the connected project. `projectId` defaults to the current project.

\**HIERARCHY — ALWAYS RESOLVE BEFORE CALLING.** A story lives under Epic → Feature → Story. Do NOT create orphan stories. Before calling this tool, confirm with the user which `epicId` and/or `featureId` the story belongs to. If the user has not told you: (1) ask them directly, or (2) if they name a parent, resolve the id via `epic_list` / `feature_list` first. When creating MULTIPLE stories from a BRD, group them under the same parent unless the BRD clearly splits them across features. Only skip parent linking if the user explicitly says "no parent" or "standalone".

\`state` and `priority` default to the project-configured defaults when omitted; pass them only when overriding. Backend requires `name`, `estimatedEffort`. **`description` and `acceptanceCriteria` must BOTH be HTML (NOT markdown) — SQA UI renders them via a Tiptap editor and persists raw HTML. See each field docstring below for the exact allowed tags, required section structure, and Given/When/Then format for AC. One-line descriptions and 3-line AC lists are not acceptable.** `customFields` may be omitted — an empty object is sent automatically.

Input parameters:

- `acceptanceCriteria` (string): REQUIRED-QUALITY: comprehensive Given/When/Then criteria as HTML (SQA UI renders through a  Tiptap editor). Use <ul><li>…</li></ul> — one AC per <li>. Aim for 5–15 criteria; a BRD  with 3 acceptance…
- `customFields` (object): Optional. Empty object `{}` sent automatically when omitted.
- `description` (string): REQUIRED-QUALITY: rich HTML write-up sourced from the BRD/spec. NOT markdown — SQA UI  stores raw HTML from a Tiptap editor. Minimum 200 words when the BRD covers this story. ALLOWED tags ONLY: <p>,…
- `epicId` (number): Parent epic numeric id. RESOLVE VIA `epic_list` OR ASK THE USER before creating — do not leave a story parent-less unless the user explicitly says "no parent".
- `estimatedEffort` (number, required)
- `featureId` (number): Parent feature numeric id. RESOLVE VIA `feature_list` OR ASK THE USER before creating — a story typically lives under a feature. Skip only if the user explicitly says "no feature".
- `iterationId` (number): Sprint numeric id (SQA `iterationId`).
- `moduleId` (number)
- `name` (string, required)
- `orphan` (boolean): Set true ONLY if the user has explicitly said the story has no parent ("standalone", "no epic/feature"). Required when BOTH `epicId` and `featureId` are omitted — the tool refuses otherwise so orphan…
- `ownerId` (array): Numeric userIds of story owners.
- `plannedEndDate` (string)
- `plannedStartDate` (string)
- `priority` (string): Optional. Defaults to the project-configured default story priority when omitted.
- `projectId` (number): Defaults to the connected project.
- `releaseId` (number)
- `state` (string): Optional. Defaults to the project-configured default story state when omitted.
- `tags` (array)
- `teamId` (array)
- `type` (string)
- `watchList` (array): Watch List (the UI email button): emails, full names or numeric userIds to receive notifications. Applied after creation.

### `story_update` (~236 tokens)

Update a user story (partial)

PATCH an existing USER STORY — pass only the fields to change plus `updateVersion` (optimistic concurrency, from the last story_get). Accepts id or business key (US_123). Pass `acceptanceCriteria` as a newline-separated string when replacing AC lines.

Input parameters:

- `acceptanceCriteria` (string)
- `customFields` (object)
- `description` (string)
- `epicId` (number)
- `estimatedEffort` (number)
- `featureId` (number)
- `id` (string, required): Story id or business key (US_123).
- `iterationId` (number)
- `moduleId` (number)
- `name` (string)
- `ownerId` (array)
- `plannedEndDate` (string)
- `plannedStartDate` (string)
- `priority` (string)
- `projectId` (number)
- `releaseId` (number)
- `state` (string)
- `tags` (array)
- `teamId` (array)
- `type` (string)
- `updateVersion` (number)

### `backlog_delete` (~240 tokens)

Delete an epic / feature / user story / defect / task

DESTRUCTIVE. Delete ONE epic, feature, user story, defect or task. `ref` is the item's NAME, business key (EP_12, FT_3, US_5, DF_7 …) or numeric id — resolved here, the user never supplies an internal id. TWO-STEP: call WITHOUT `confirm` to get a preview (what will be deleted + anything that depends on it); show it to the user and ASK; only then call again with `confirm:true`. An item that still has dependents (an epic with features/stories, a feature/story with children or test cases, a defect with test cases/tasks) is REFUSED with the blockers listed — nothing cascades. An ambiguous name lists the matches and deletes nothing. Needs the user's delete permission; no agent required. Requires a live connection.

Input parameters:

- `confirm` (boolean): Set true ONLY after the user has seen the preview and explicitly confirmed the delete.
- `kind` (string, required): Which kind of item to delete.
- `ref` (string, required): Name, business key (EP_/FT_/US_/DF_…) or numeric id of the item.

### `watch_list_add` (~138 tokens)

Add members to the Watch List of an epic, feature or user story

Add people to an item's WATCH LIST — the same list the UI's email button edits. `users` takes emails, full names or numeric userIds (e.g. ["rohini.k@simplify3x.com"]). Existing watchers are kept; the item is re-read to confirm. Use it after creating an item, or for an existing one.

Input parameters:

- `entityType` (string, required): Which backlog item.
- `itemId` (string, required): Item id or business key (EP-66, FT-266, US-1326).
- `users` (array, required): Emails, full names or numeric userIds to add to the Watch List.

### `backlog_link` (~229 tokens)

Link an epic / feature / user story / defect to another item (Linkages)

Create a LINK between an epic, feature, user story or DEFECT and another backlog item (defect, epic, feature, story, task) — the UI's Linkages section. `linkType` is a link type name/key such as "Clones" (case-insensitive; the available types are read from the project's link-type config and an unknown one is refused with the list). `destType` is the DESTINATION issue type (e.g. "defect"). The link is saved on the SOURCE item and read back from /pm/linkages to confirm.

Input parameters:

- `destId` (string, required): Destination id or business key (DE-2293).
- `destType` (string, required): Destination issue type.
- `linkType` (string, required): Link type name or key, e.g. "Clones".
- `sourceId` (string, required): Source item id or business key (EP-64, FT-266, US-1326, DE-75).
- `sourceType` (string, required): Item that owns the Linkages section (a defect too — its Linkages section).

### `backlog_unlink` (~283 tokens)

Remove a link between two backlog items (Linkages)

DELETE a LINK between two backlog items — the UI's Linkages delete (the opposite of backlog_link). Pass the item that owns the link (`sourceType` + `sourceId`, e.g. epic EP-71) and the item it points to (`destType` + `destId`, e.g. defect DE-2293). If the source has more than one link to that item, say which with `linkType` (e.g. "Clones"). The link disappears from BOTH items' Linkages; the tool reads the source's Linkages back to confirm and checks the other side too. A link that is not there is reported with the links the source does have. Deleting is final — call it only when the user asked to remove the link.

Input parameters:

- `destId` (string, required): The linked item's id or business key (DE-2293).
- `destType` (string, required): The linked item's type.
- `linkType` (string): Link type name or key (e.g. "Clones") — needed only when the source has several links to that item.
- `sourceId` (string, required): Source item id or business key (EP-71, FT-266, US-1326, DE-2293, TA-3).
- `sourceType` (string, required): Item type that owns the Linkages row.

### `failure_analysis` (~996 tokens)

Analyse failed SimplifyQA test cases, suites or execution plans

Analyse FAILED SimplifyQA executions — test cases, suites, execution plans — together. ANALYSE: `codes` (TC-123 / SU-123 / PL-123, each → its latest execution) and/or `executionIds` (id or EX code); `code` / `executionId` work too. Returns an `analysisId` (FA-…), a card (scope, failures by category with counts and %, patterns, failed test cases) and evidence per pattern.
VIEW: pass `analysisId` (no re-fetch) with `view` ("consolidated" | "suite"), `suiteId`, `pattern` (n or [n,…]), `category` or `page`.
REVIEW: `{ analysisId, review: true, page? }` — every failed test case, as many per page as fit 18 images: its failed step and the same step in the last pass at the same detail (expected / actual, test data, full API, locator, logs), with every screenshot of both steps, the baseline of both runs and the element thumbnail.
Images: the failed screenshot is this run. The baseline is the execution-time reference page with the target element boxed in red. The thumbnail is the target element as recorded. Same page as the baseline but the element missing or different from the thumbnail means the element or locator changed. A different page (error, blank, another screen) means the flow did not reach it. Recorded images show recording-time data: compare layout and element, not values.

Do this, in order:
(1) Read the card and the evidence.
(2) Page the remaining groups with `pattern:[…]` exactly as the card's "Next:" line says, until every pattern's evidence has been read.
(3) Review every failed test case with `review: true`, following its "Next:" line until done: compare the last passed step with the failed step (data, API, locator, logs, version, every image) and state what changed and what stayed the same.
(4) Call `failure_analysis_classify` ONCE with a verdict for ALL groups (`splitOut` test cases whose review shows another cause; `mergeInto` groups that share one).
(5) Reply starting with the classified card exactly as returned (same tables and rows, never reworded),…

Input parameters:

- `analysisId` (string): VIEW an existing analysis (FA-…) instead of analysing again.
- `category` (string): With analysisId: only this category.
- `code` (string): One code (same as codes:[code]).
- `codes` (array): TC-123 / SU-123 / PL-123 — each analysed at its latest execution.
- `compareWithLastPass` (boolean): Compare each pattern's failure with the last pass (default true).
- `executionId` (string): One execution id or EX code (same as executionIds:[id]).
- `executionIds` (array): Execution ids or EX codes — only these executions.
- `includeImages` (boolean): Return failed / last-passed screenshot pairs for the patterns shown as inline images (default true; analyse and view). Set false for text only.
- `includeLogs` (boolean): Include execution logs (default true).
- `includeScreenshots` (boolean): Include screenshot artifact URLs (default true).
- `maxLogLines` (integer): Cap logs per step — the lines nearest the failure are kept (default 30).
- `page` (integer): With analysisId: page of the groups list (or of the review with review:true).
- `pattern`: With analysisId: these pattern groups, with full evidence.
- `review` (boolean): With analysisId: review EVERY failed test case, as many per page as fit 18 images (failed step vs the last pass, with every image of both). Follow its "Next:" line until done.
- `runId` (string): Same as executionId (kept for older calls).
- `suiteId` (string): With analysisId: only this suite (SU-12 or 12). Without it: same as code SU-<id>.
- `tcId` (string): Test case id — same as code TC-<id>.
- `view` (string): View: one list (default) or per suite.

### `failure_analysis_classify` (~351 tokens)

Record verdicts for a failure analysis

Record your verdict for EVERY pattern group of a failure analysis, in ONE call, after reading the evidence of all of them (page unseen groups with failure_analysis({ analysisId, pattern: [...] }) first — a group whose evidence was never shown is rejected) and reviewing every failed test case with failure_analysis({ analysisId, review: true }). Use `splitOut` for test cases whose review shows a different cause and `mergeInto` for groups that share a root cause. An incomplete review is accepted; the card then says how many test cases were reviewed. The MCP applies merges / splits, recomputes counts and %, and returns the classified card: start your reply with it exactly as returned. Calling again overwrites a group's verdict. Changes only this MCP's memory — nothing is written to SimplifyQA. Categories: APP_DEFECT — the application does something wrong with an unchanged test and unchanged data. NEW_CHANGE — the application changed on purpose (screen, label, flow, rule or expected value), so the test is now outdated. AUTOMATION_DATA — script, locator, timing/synchronisation, test data, configuration, environment/device, or a manual stop.

Input parameters:

- `analysisId` (string, required): Id from failure_analysis (FA-xxxxxxxx).
- `verdicts` (array, required): One entry per pattern group: { group, pattern (short name), rootCause (one or two sentences, from the evidence), category (APP_DEFECT | NEW_CHANGE | AUTOMATION_DATA), confidence (high | medium | low)…

### `failure_analysis_export` (~402 tokens)

Export a failure analysis to Excel / PDF

Write the official report files for a stored failure analysis (from `failure_analysis`): Excel (`xlsx`) and/or PDF (`pdf`), plus `analysis.json`. Pass the `analysisId` it returned and the `format`. Optional filters (`suiteId`, `pattern`, `category`, `view`) are applied to every file. Files are saved under `outDir` (default ./qa-reports) and their paths returned. Protected test data is masked as ***. Optional `layout` reshapes the report to what the user asked for: `title`, `sections` (summary is always kept; order is fixed), test-case `columns` in the wanted order (keys: patternNo, source, code, name, iteration, failedStep, expected, actual, pattern, category, reason, lastPassed, failingSince, editedSincePass, report, screenshot, lastPassedScreenshot, baseline; code is always included), `groupBy` (pattern | source | category), `sortBy` (pattern | code | failingSince | lastPassed | category), and up to 5 `extraColumns` ({ header, values: { "<test case code>": "<text>" }, default? }) — fill extra values only from evidence you reviewed. Counts and percentages are always computed by the server. Omit `layout` for the standard report; a custom layout gets its own file name.

Input parameters:

- `analysisId` (string, required): Id from failure_analysis (FA-xxxxxxxx).
- `category` (string)
- `format` (array, required): Which files to write: "xlsx", "pdf" or both.
- `layout` (object): Customise the report to the user request. Omit for the standard report.
- `outDir` (string): Folder to save into. Default: ./qa-reports
- `pattern`: Only these pattern ids.
- `suiteId` (string): Only this suite.
- `view` (string)

### `cloud_runners` (~51 tokens)

List cloud runners (and which are online)

List the cloud runner VMs registered to the connected project and which are online. Use this to show the user the cloud options, or to pick a specific runner id for tc_run. Requires a live connection.

### `local_agents` (~107 tokens)

List THIS machine's local agent(s)

List the LOCAL agent(s) registered from THIS machine — the desktop agent running on the box this MCP is on. Use for a LOCAL tc_run / suite_run. There is exactly one desktop agent per machine, so this is 0 or 1 row: empty means no agent is registered from this box (start the SimplifyQA desktop agent, or use mode:'remote' to dispatch to a teammate's). Use `remote_agents` for the other registered machines. Requires a live connection.

### `remote_agents` (~102 tokens)

List REMOTE agents (other registered machines)

List the LOCAL agents registered on OTHER machines (teammates' boxes) — the pool a REMOTE run dispatches to. Use to pick an `agentId` for a REMOTE tc_run / suite_run. Excludes this machine's own agent (that's `local_agents`). REMOTE dispatches to a specific teammate's registered desktop agent through the SimplifyQA queue; the picked agent's browsers / adb devices are what actually execute. Requires a live connection.

### `mobile_list_devices` (~221 tokens)

List mobile devices (Android or iOS)

List MOBILE devices available to the project — union of the LOCAL roster (real devices + emulators/simulators registered via the desktop agent, from `/tm/mobileDevices/search`) and the CLOUD roster (whichever farm the project has integrated: LambdaTest / BrowserStack / SauceLabs / SimplifyQA Device Farm — the first non-empty one wins, matching the UI's single-provider-per-project model). Use before `tc_run` for an ANDROID or IOS test case to pick a `deviceId` (and read `deviceType` + `cloudDeviceType` off the same row). The `active` flag on local rows is last-known: stale by design (the SQA backend writes it when the desktop agent connects/disconnects, and a 7s-stale cron flips it back); a device the user just plugged in may still read `active:false` here. Cloud rows don't carry `active` — cloud farms are always assumed reachable. Requires a live connection.

Input parameters:

- `platform` (string, required): Which mobile platform to list devices for.

### `tc_run` (~2448 tokens)

Run a test case (local / remote / cloud; now or scheduled)

★ ORDER OF QUESTIONS (STRICT — applies whether you ask one at a time OR bundle several into a single message): when → mode → release → sprint → version → environment → browser/device → schedule fields → agent. Ask in THIS order, always — never schema-declaration order, never refusal-arrival order, never a 'natural UI' order (release first is WRONG). Skip a step only when the flag below says it's skippable (sprint when release='', version when TC has one version, browser vs. device by TC type). ★

Execute ONE existing test case in the connected product. ASK the user for EVERY field the Execute dialog asks — never assume — in this DEPENDENCY ORDER: (0) if a previous run in this session left a config for the project, the tool refuses first asking `reuseConfig` (true=merge remembered mode/release/sprint/env/browser/agent, false=start fresh); (1) `when` immediate/schedule, (2) `mode` local/remote/cloud, (3) `releaseId` (from list_releases; pass '' to skip — no release), (4) `sprintId` (from list_sprints; skipped entirely when releaseId=''), (5) `versionId` (from tc_get's `versions[]`; pass '' for current), (6) `environment` (from tc_list_environments), (7) FOR WEB TCs: `browser`; FOR ANDROID/IOS TCs: `deviceType` + `deviceId` (via `mobile_list_devices`), (8) for a schedule the start time + recurrence (ASK — Once / Every 5 Minutes / Hourly / Daily / Weekly / Monthly, never default) + end date + timezone, (9) THEN offer the eligible agent/runner and pass the pick. IF YOU BATCH SEVERAL REFUSED FIELDS INTO ONE AskUserQuestion, ORDER the questions EXACTLY as above (when → mode → release → sprint → version → environment → browser/device → schedule fields → agent) — never in schema order or refusal order. `mode` decides WHERE it runs:
  • 'local' — THIS machine's desktop agent (its own browser). Call `local_agents` (0 or 1 row per box). For when:'immediate' the tool first probes the desktop agent (:4040) and refuses cleanly if it's not up. Omit `agentId` to auto-pick this mach…

Input parameters:

- `agentId` (string): STEP 9 — for local: a credential_id from `local_agents` (must be THIS machine's row; omit to auto-pick). For remote: REQUIRED — a credential_id from `remote_agents`. when:'immediate' → the picked age…
- `browser` (string): STEP 7 (WEB TCs) — browser, default 'chromium' (bundled + isolated). Others: 'chrome'/'msedge' (installed channel), 'firefox', 'webkit'. ON THE CLOUD (mode 'cloud') the ONLY choices are Chrome Headle…
- `cloudDeviceType` (string): REQUIRED when `deviceType` is cloud_* — which cloud farm the device came from (read off the matching row's `cloudDeviceType`).
- `cloudRunnerId` (string): STEP 9 (cloud) — a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time.
- `dayOfMonth` (integer): Monthly 'ON DAY': 1–30; default = the start's day.
- `daysOfWeek` (array): Weekly: the weekdays to run on (MONDAY … SUNDAY or MON … SUN); default = the start's weekday. Monthly with `occurrence`: the one weekday.
- `deviceId` (string): STEP 7 (ANDROID/IOS TCs) — the target device id. LOCAL: adb serial or emulator name. CLOUD: the marketplace device name. Enumerate with `mobile_list_devices`.
- `deviceName` (string): STEP 7 (ANDROID/IOS TCs) — the human-readable device name (e.g. 'Oppo-Cph2375-Ab1fe936', 'Pixel 7'). Read off the matching row's `displayName` (preferred) or `name` field from `mobile_list_devices`.…
- `deviceType` (string): STEP 7 (ANDROID/IOS TCs) — the KIND of device the picked `deviceId` is (read off the matching row from `mobile_list_devices`).
- `devices` (array): STEP 7 (ANDROID/IOS TCs) — for PARALLEL execution on MULTIPLE devices. Pass an array of device specs to create ONE execution with one run per device (parallel). When provided, the single-device field…
- `endDate` (string): SCHEDULE STEP — ISO end date; REQUIRED when scheduleType is anything but 'once'. ASK the user.
- `environment` (string): STEP 6 — environment key (from tc_list_environments). ASK the user on EVERY run; the UI marks this required. Never inherited from a previous run — reuseConfig does not fill it.
- `headless` (boolean): Headless. Defaults: cloud=true, local=false. (Immediate runs only.)
- `interval` (integer): REPEAT EVERY N for hourly / daily / weekly / monthly — N hours / days / weeks / months (e.g. hourly + 2 = every 2 hours). Default 1. With 'every_5_minutes' it is the N in 'every N minutes'. Not for '…
- `mode` (string): STEP 2 — where to run. REQUIRED, ASK the user if unstated.
- `occurrence` (string): Monthly 'ON THE': the first / second / third / last weekday of the month — give the weekday in daysOfWeek.
- `osVersion` (string): Optional OS version to stamp on the wire platform object for ANDROID/IOS — read off the matching row from `mobile_list_devices`.
- `releaseId` (string): STEP 3 — tag the run with a RELEASE (from list_releases). Optional in the UI; pass '' after asking to skip. The tool refuses when undefined so the user is asked.
- `reuseConfig` (boolean): Set only when the tool refused asking about REUSE. true = merge the previous run's mode/release/sprint/browser/agent/runner into any unset field; the ENVIRONMENT is never merged — it is asked on ever…
- `scheduleName` (string): when:'schedule' — the schedule's NAME as the Scheduler shows it (3–501 characters, unique in the project), e.g. 'nightly smoke'. Omit it and the schedule is named '<TC-22> schedule' (numbered when ta…
- `scheduleType` (string): SCHEDULE STEP — REQUIRED for when:'schedule'; ASK the user explicitly, never assume. The UI's Recurrence choices: 'once', 'every_5_minutes', 'hourly', 'daily', 'weekly', 'monthly'. Anything but 'once…
- `scheduledFor` (string): STEP 8 — REQUIRED for when:'schedule'; ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z').
- `sprintId` (string): STEP 4 — tag the run with a SPRINT (from list_sprints, scoped to release). Only asked when releaseId is non-empty; skipped entirely when releaseId=''. Pass '' after asking to skip.
- `strategy` (string): STEP 3 (IMMEDIATE runs) — SERIAL or PARALLEL: the same PARALLEL/SERIAL radio the UI's Execute dialog shows above Release (it applies to LOCAL, REMOTE and CLOUD alike). ASK the user; the tool refuses…
- `tcId` (string, required): The test case id (or business key) to run.
- `timezone` (string): IANA timezone for a schedule (e.g. 'Asia/Kolkata'). Default 'UTC'.
- `versionId` (string): STEP 5 — override the TC's currently-selected VERSION for this run (an id or name from the TC's `versions[]`). Pass '' to accept the TC's current version.
- `when` (string): STEP 1 — when to run. REQUIRED, ASK the user if unstated (the tool refuses when omitted). 'immediate' dispatches now; 'schedule' creates a schedule (needs scheduledFor).

### `suite_run` (~2185 tokens)

Run a test suite (local / remote / cloud; now or scheduled)

★ ORDER OF QUESTIONS (STRICT — applies whether you ask one at a time OR bundle several into a single message): when → mode → strategy (serial/parallel, IMMEDIATE runs) → release → sprint → environment → schedule fields → agent. Ask in THIS order, always — never schema-declaration order, never refusal-arrival order, never a 'natural UI' order (release first is WRONG). Skip sprint when release=''. Suites do NOT ask version / browser / device — each TC in the suite carries its own. ★

Execute an existing test SUITE — all its member test cases, in order — in the connected product. ASK the user for EVERY field the UI's Execute-suite dialog asks — never assume — in this DEPENDENCY ORDER: (0) if a previous run in this session left a config for the project, the tool refuses first asking `reuseConfig` (true=merge remembered mode/release/sprint/agent (the ENVIRONMENT is always asked), false=start fresh); (1) `when` immediate/schedule, (2) `mode` local/remote/cloud, (3) `strategy` SERIAL/PARALLEL — the UI's PARALLEL/SERIAL radio, shown for LOCAL, REMOTE and CLOUD alike (ask it for an immediate run), (4) `releaseId` (from list_releases; pass '' to skip), (5) `sprintId` (from list_sprints; skipped entirely when releaseId=''), (6) `environment` (from tc_list_environments), (7) for a schedule the start time + recurrence (ASK — Once / Every 5 Minutes / Hourly / Daily / Weekly / Monthly, never default) + end date + timezone, (8) THEN offer the eligible agent/runner. IF YOU BATCH SEVERAL REFUSED FIELDS INTO ONE AskUserQuestion, ORDER the questions EXACTLY as above (when → mode → strategy → release → sprint → environment → schedule fields → agent) — never in schema order or refusal order. UNLIKE `tc_run`, a suite does NOT ask for `versionId` or `browser` — each TC in the suite carries its own pinned version + execution platform (that's what the suite editor picks per row). ★ RECOMMEND PARALLEL when the suite has more than one test case that can run independently (they dispatch concur…

Input parameters:

- `agentId` (string): STEP 8 — for local: a credential_id from `local_agents` (this machine only; omit to auto-pick). For remote: REQUIRED — a credential_id from `remote_agents`. when:'immediate' → picked agent must be ON…
- `browser` (string): Optional at the SUITE level — each TC in the suite has its own execution platform (that's the suite-editor pick per row). Provide only to OVERRIDE for every WEB TC. Values: 'chromium' (default), 'chr…
- `cloudRunnerId` (string): STEP 8 (cloud) — a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time.
- `dayOfMonth` (integer): Monthly 'ON DAY': 1–30; default = the start's day.
- `daysOfWeek` (array): Weekly: the weekdays to run on (MONDAY … SUNDAY or MON … SUN); default = the start's weekday. Monthly with `occurrence`: the one weekday.
- `endDate` (string): SCHEDULE STEP — ISO end date; REQUIRED when scheduleType is anything but 'once'. ASK the user.
- `environment` (string): STEP 6 — environment key (from tc_list_environments). ASK the user on EVERY suite run; the UI marks this required for a suite. Never inherited from a previous run — reuseConfig does not fill it.
- `headless` (boolean): Headless. Defaults: cloud=true, local=false. (Immediate runs only.)
- `interval` (integer): REPEAT EVERY N for hourly / daily / weekly / monthly — N hours / days / weeks / months (e.g. hourly + 2 = every 2 hours). Default 1. With 'every_5_minutes' it is the N in 'every N minutes'. Not for '…
- `maxConcurrent` (integer): Cloud parallel only — maps to globalConfiguration.MAXIMUM_CONTAINER_COUNT on the wire.
- `mode` (string): STEP 2 — where to run. REQUIRED, ASK the user if unstated. 'stack' runs the suite's saved Stack setup (the UI's Execution Type → Stack): set it up first with suite_manage action:'stack_setup'; immedi…
- `occurrence` (string): Monthly 'ON THE': the first / second / third / last weekday of the month — give the weekday in daysOfWeek.
- `releaseId` (string): STEP 4 — release from list_releases. ASK the user; pass '' to skip (no release / no sprint asked).
- `reuseConfig` (boolean): Set only when the tool refused asking about REUSE. true = merge the previous run's mode/release/sprint/browser/agent/runner into any unset field; the ENVIRONMENT is never merged — it is asked on ever…
- `scheduleName` (string): when:'schedule' — the schedule's NAME as the Scheduler shows it (3–501 characters, unique in the project), e.g. 'nightly smoke'. Omit it and the schedule is named '<TC-22> schedule' (numbered when ta…
- `scheduleType` (string): SCHEDULE STEP — REQUIRED for when:'schedule'; ASK the user explicitly, never assume. The UI's Recurrence choices: 'once', 'every_5_minutes', 'hourly', 'daily', 'weekly', 'monthly'. Anything but 'once…
- `scheduledFor` (string): STEP 6 — REQUIRED for when:'schedule'; ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z').
- `sprintId` (string): STEP 5 — sprint from list_sprints (scoped to release). Only asked when releaseId is non-empty; skipped when releaseId=''. Pass '' to skip.
- `strategy` (string): STEP 3 (immediate runs) — SERIAL or PARALLEL across the suite's test cases: the same choice the UI's Execute-suite dialog shows as a PARALLEL/SERIAL radio, and it applies to LOCAL, REMOTE and CLOUD a…
- `suiteId` (string, required): The suite id to run (from suite_list / suite_get).
- `terminateOnFailure` (boolean): Stop dispatching remaining test cases after the first failure. Maps to globalConfiguration.TERMINATE_ON_FAIL on the wire.
- `timezone` (string): IANA timezone for a schedule (e.g. 'Asia/Kolkata'). Default 'UTC'.
- `when` (string): STEP 1 — when to run. REQUIRED, ASK the user if unstated.

### `run_status` (~314 tokens)

Get a run status

Read the status of a run — state (queued/running/passed/failed/skipped/notExecuted/stopped/error), progress, per-test-case rollup for a SUITE run (capped at 100 shown, ONE ROW PER TEST CASE — not per iteration), and a link. Every state SQA reports is its own bucket in the per-state tally (skipped and notExecuted are real, distinct outcomes — never counted as passed or folded into queued). While the run is still queued/running, the tally is labelled provisional. Pass EITHER `runId` (from tc_run / suite_run) or `suiteId` (from suite_list) to read that suite's LATEST execution.

The suite rollup only says pass/fail/etc per test case, never WHY — to get one child's own step-level detail (which step failed, the error), call again with the SAME `runId`/`suiteId` plus `tcId` set to one of the ids shown in the rollup. Requires a live connection.

Input parameters:

- `runId` (string): The run id returned by tc_run or suite_run.
- `suiteId` (string): A suite id (from suite_list) — resolves to the suite's latest execution.
- `tcId` (string): Drill into ONE child test case's step-level results within a SUITE run — its id from the rollup shown by a prior run_status call (without `tcId`). Ignored / refused for a single-TC run.

### `run_history` (~209 tokens)

Recent execution history for a suite or test case

Return the top-N most recent STANDALONE executions of a suite or test case (newest first), as a scoreboard — runId, state, timing, reportUrl, plus a per-test-case tally for SUITE runs (passed/failed/skipped of total). No step-level detail; use `run_status({ runId })` on any row to drill in. Pass EXACTLY one of `suiteId` or `tcId`. `limit` defaults to 5, capped at 20. Suite-child TC rows are excluded from a `tcId` query, so a test case that only runs inside suites returns empty. Requires a live connection.

Input parameters:

- `limit` (integer): How many recent runs to return (default 5, max 20).
- `suiteId` (string): A suite id (from suite_list) — returns the suite's recent executions.
- `tcId` (string): A test case id — returns the TC's recent STANDALONE executions.

### `run_stop` (~158 tokens)

Stop a run

Signal a running execution to stop, and poll briefly for the terminal state so the reply reflects reality (not a fire-and-forget). Pass EXACTLY one of: `runId` (from tc_run / suite_run), `suiteId` (stops the suite's LATEST execution), or `tcId` (stops the TC's LATEST standalone execution — suite-child rows are excluded). Requires a live connection.

Input parameters:

- `runId` (string): The run id (from tc_run / suite_run).
- `suiteId` (string): A suite id (from suite_list) — stops the suite's latest execution.
- `tcId` (string): A test case id — stops the TC's latest STANDALONE execution.

### `schedule_list` (~80 tokens)

List schedules

List the scheduled runs in the connected project — each with WHAT it runs (test case / suite), its cadence, next run time, status (scheduled / running / paused / cancelled), where it runs + the pinned agent, and its browser. Use this to find a schedule to edit, pause/resume, cancel, or delete. Requires a live connection.

### `schedule_update` (~791 tokens)

Edit a schedule

Change a schedule's NAME / WHAT IT RUNS (a test case or a suite — `testCaseId` or `suiteId`; the schedule switches between Test Case and Suite as the Scheduler form does, keeping the same id) / time / recurrence / end date / timezone / browser / environment / release / sprint, or RE-PIN its agent. Pass `scheduleId` (from schedule_list) and ONLY the fields to change. To re-pin: mode:'local' + `agentId` (from local_agents), or mode:'cloud' + a runner's `cloudRunnerCredentialId` (the `credentialId` from cloud_runners). Requires a live connection.

Input parameters:

- `agentId` (string): Local re-pin: an agent credential_id from local_agents.
- `browser` (string): New browser for a WEB test case / suite schedule. For a SCHEDULE on SimplifyQA, 'chrome' (and 'chromium') = Chrome, 'msedge'/'edge' = Edge, 'firefox', 'webkit'/'safari' = Safari — chrome is fine; on…
- `cloudRunnerCredentialId` (string): Cloud re-pin: a runner's credentialId from cloud_runners.
- `dayOfMonth` (integer): Monthly 'ON DAY': 1–30; default = the start's day.
- `daysOfWeek` (array): Weekly: the weekdays to run on (MONDAY … SUNDAY or MON … SUN); default = the start's weekday. Monthly with `occurrence`: the one weekday.
- `endDate` (string): New ISO end date (for recurring schedules).
- `environment` (string): New environment id (Mongo id).
- `interval` (integer): REPEAT EVERY N for hourly / daily / weekly / monthly — N hours / days / weeks / months (e.g. hourly + 2 = every 2 hours). Default 1; giving it alone changes the schedule's current cadence. With 'ever…
- `mode` (string): Re-pin target: pair with agentId (local) or cloudRunnerCredentialId (cloud).
- `name` (string): Rename the schedule (3–501 characters, unique in the project) — the name the Scheduler shows.
- `occurrence` (string): Monthly 'ON THE': the first / second / third / last weekday of the month — give the weekday in daysOfWeek.
- `releaseId` (string): Release: id, code (RE-44) or exact name; "none" clears it. A suite schedule needs one.
- `scheduleId` (string, required): The schedule id (from schedule_list).
- `scheduleType` (string): New recurrence (same choices as the UI: once, every_5_minutes, hourly, daily, weekly, monthly). Anything but once needs an endDate.
- `scheduledFor` (string): New start / next-run ISO datetime.
- `sprintId` (string): Sprint: id, code (SP-1) or exact name; it must belong to the release. "none" clears it.
- `suiteId` (string): Make it run THIS suite (id or code, e.g. SU-4) — a test-case schedule becomes a Suite schedule (which needs a release). Not together with testCaseId.
- `testCaseId` (string): Make it run THIS test case (id or code, e.g. TC-35) — a suite schedule becomes a Test Case schedule. Not together with suiteId.
- `timezone` (string): New IANA timezone (e.g. 'Asia/Kolkata').

### `schedule_control` (~96 tokens)

Pause / resume / cancel a schedule

Change a schedule's state: `pause` (stop it firing but keep it — reversible with `resume`), `resume` (re-enable a paused schedule), or `cancel` (stop its pending / live run). To remove a schedule entirely, use schedule_delete instead. Requires a live connection.

Input parameters:

- `action` (string, required): pause / resume / cancel.
- `scheduleId` (string, required): The schedule id (from schedule_list).

### `schedule_delete` (~100 tokens)

Delete a schedule

Permanently DELETE a schedule (and tear down any run it currently owns). This cannot be undone — to only stop it temporarily use schedule_control (pause / cancel). CONFIRM with the user before deleting. Requires a live connection.

Input parameters:

- `confirm` (boolean): SimplifyQA: the first call only previews; pass true on the SECOND call, after the user explicitly said to delete.
- `scheduleId` (string, required): The schedule id (from schedule_list).

### `suite_manage` (~857 tokens)

Update or delete a suite (SimplifyQA)

Change, read or remove an existing SimplifyQA suite. Pick ONE `action`:
\- action:"get" — needs `suiteId`. READS the suite's Settings panel: execution type and autoReExecCount / autoDefectLog / autoReExecTriggerOn / newBrowserSession / terminateOnFailure / container limits. Use it to CONFIRM a setting after saving (also after a client restart — the settings live in the backend).
\- action:"update" — needs `suiteId` and at least one of `name`, `description`, `executionType` (the suite's Execution Type menu: "local", "remote", "cloud" or "stack"), `settings` (autoDefectLog, autoReExecCount, autoReExecTriggerOn, newBrowserSession, terminateOnFailure, minimumContainerCount, maximumContainerCount).
\- action:"delete" — needs `suiteId`. TWO-STEP: call without `confirm` to PREVIEW (nothing is deleted), show it to the user, and call again with `confirm:true` ONLY after the user explicitly says to delete. A suite still used by a schedule, pipeline, execution plan or test plan is refused.
\- action:"stack_setup" — needs `suiteId` and `stacks` (how many) or `stackConfigs`. Saves the suite's STACK setup (the Stack canvas behind Execution Type → Stack). Saves the Stack Setup (what the Stack canvas saves). Give `stacks` (a number: that many alike, test cases spread round-robin) OR `stackConfigs` (one entry per stack: its platform local / remote / cloud, browser, remote machine and, if the user says which, its test cases). `append:true` ADDS stacks to the saved setup instead of replacing it (existing stacks keep their platform; with no test cases named, all are re-spread over old + new). Every stack needs at least one test case, a REMOTE stack needs a machine, and CLOUD needs a cloud machine configured for the project. Run it afterwards with mode:"stack". `stackMode` "cloud" (default) or "local" and `browser` are the defaults for stacks that do not say.
AUTO DEFECT LOGGING for the suite = action:"update" with settings:{ autoDefectLog:true } (failed steps then log a defect automatical…

Input parameters:

- `action` (string, required): What to do with the suite.
- `append` (boolean): action "stack_setup": add the stack(s) to the saved setup instead of replacing it.
- `browser` (string): action "stack_setup": browser for WEB test cases (default chrome).
- `confirm` (boolean): action "delete": true on the SECOND call, only after the user explicitly said to delete.
- `description` (string): action "update": the new description.
- `executionType` (string): action "update": the suite's Execution Type (the UI menu) — "stack" selects Stack execution. Sent as lastSelectedExecutionType.
- `name` (string): action "update": the new name.
- `settings` (object): action "update": execution settings to change.
- `stackConfigs` (array): stack_setup: describe each stack, in order — one entry per stack (this sets the number of stacks; leave `stacks` out or make it match). E.g. [{ mode:"local" }, { mode:"cloud" }, { mode:"remote", agen…
- `stackMode` (string): action "stack_setup": where the stacks run (default cloud).
- `stacks` (integer): action "stack_setup": number of stacks — with append:true, how many to ADD. Omit when stackConfigs lists them.
- `suiteId` (string): Suite id or code (SU-12). Needed by every action.

### `execution_plan` (~1620 tokens)

Create, update or delete an execution plan (SimplifyQA)

Manage SimplifyQA execution plans. Read plans with sqa_query (collection "executionPlans"). Pick ONE `action`:
\- action:"create" — needs `name`, `plannedStartDate`, `plannedEndDate` (YYYY-MM-DD) and `environment` (name or key; see sqa_query collection "environments"). Optional: releaseId, sprintId, teamIds, planners, autoReExecCount, autoReExecTriggerOn, autoDefectLog, newBrowserSession, terminateOnFailure.
\- action:"update" — needs `planId` and at least one field to change (same fields as create). AUTO DEFECT LOGGING for the plan = `autoDefectLog:true` (create or update): failed steps then log a defect automatically. It needs the project's admin "Auto Defect Logging" switch on; if it is off the call is refused with that instruction — tell the user to ask an admin to enable it, then retry.
\- action:"delete" — needs `planId`. TWO-STEP: call without `confirm` to PREVIEW (nothing is deleted; it states what is permanently lost), show it to the user, and call again with `confirm:true` ONLY after the user explicitly says to delete.
\- action:"add_testcases" - needs `planId` and `tcIds`, `testCases` and/or `suiteIds` (a suite adds its test cases). Optional `assignTo` (user id or "me") and `assignDate` (YYYY-MM-DD); only assigned test cases can run. To pin a VERSION pass `testCases:[{ tcId:"TC-12826", version:"v2.0" }]` (or `versionId`, or one `versionId`/`version` for every `tcIds` entry) — the same test case can sit in the plan once per version, so v1.0 and v2.0 are two entries. A version that does not exist is an ERROR; a duplicate (same test case AND version) is skipped.
\- action:"remove_testcases" — needs `planId` and `tcIds`. TWO-STEP like delete: removing also DELETES those test cases' run history in SimplifyQA, which cannot be undone.
\- action:"stack_setup" — needs `planId` and `stacks` (how many, e.g. 2) or `stackConfigs`. Saves the Stack Setup (what the Stack canvas saves). Give `stacks` (a number: that many alike, test cases spread round-robin) OR `stackConfigs`…

Input parameters:

- `action` (string, required): What to do.
- `agentId` (string): run: this machine's agent id (optional; auto-picked, see local_agents).
- `append` (boolean): stack_setup: add the stack(s) to the saved setup instead of replacing it.
- `assignDate` (string): add_testcases: YYYY-MM-DD.
- `assignTo` (string): add_testcases: user id, or "me".
- `autoDefectLog` (boolean): create/update: log a defect automatically when a step fails (needs the project's admin Auto Defect Logging switch on).
- `autoReExecCount` (integer): create/update.
- `autoReExecTriggerOn` (string): create/update.
- `browser` (string): stack_setup: browser for WEB test cases (default chrome). run, mode "cloud": the browser for the plan's web test cases — ONLY Chrome Headless, Firefox Headless or Edge Headless (pass chrome / firefox…
- `confirm` (boolean): delete: true on the SECOND call, only after the user explicitly said to delete.
- `environment` (string): create/update: environment name or key.
- `mode` (string): run: "local" (this machine's agent), "cloud" (a configured cloud machine), or "stack" (the saved stack setup, divided across its stacks).
- `name` (string): create/update: plan name (unique in the project).
- `newBrowserSession` (boolean): create/update.
- `planId` (string): Every action except create: plan id or code (PL-5).
- `plannedEndDate` (string): create/update: YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string): create/update: YYYY-MM-DD.
- `planners` (array): create/update: planner user ids.
- `releaseId` (string): create/update: release id.
- `sprintId` (string): create/update: sprint id (needs a release).
- `stackConfigs` (array): stack_setup: describe each stack, in order — one entry per stack (this sets the number of stacks; leave `stacks` out or make it match). E.g. [{ mode:"local" }, { mode:"cloud" }, { mode:"remote", agen…
- `stackMode` (string): stack_setup: what each stack runs on (default cloud).
- `stacks` (integer): stack_setup: how many stacks (e.g. 2) — with append:true, how many to ADD. Omit when stackConfigs lists them.
- `suiteIds` (array): add_testcases: suites whose test cases to add.
- `tcIds` (array): add_testcases / remove_testcases: test case ids or codes.
- `teamIds` (array): create/update: team ids.
- `terminateOnFailure` (boolean): create/update.
- `testCases` (array): add_testcases: test cases with an explicit version — lets one TC be added once per version (v1.0 AND v2.0).
- `version` (string): add_testcases: pin one version by NAME for every tcIds entry (e.g. v2.0).
- `versionId` (string): add_testcases: pin ONE version for every tcIds entry (id or name `version`). Omit = current version.
- `when` (string): run: only "immediate" — execution plans cannot be scheduled in SimplifyQA.

### `release_update` (~321 tokens)

Update or close a release (SimplifyQA)

Change or CLOSE a SimplifyQA release. Read releases with sqa_query (collection "releases"). Pass `releaseId` (id, code like RE-44, or exact name) and either `close:true` (sets the project's completed-type state and the actual end date) or `state`, and/or name, dates, description, estimatedEffort, ownerIds. It reads the release back and reports the stored state. Only an admin user can edit a release in SimplifyQA. Closing warns when the release still has sprints that are not completed.

Input parameters:

- `actualEndDate` (string): YYYY-MM-DD.
- `actualStartDate` (string): YYYY-MM-DD.
- `close` (boolean): true = close it: the project's completed-type state (Completed / Released / Closed) and the actual end date. Use this for "close release RE-44".
- `description` (string)
- `estimatedEffort` (number)
- `name` (string): New name (3–500 characters).
- `ownerIds` (array): Owner user ids (replaces the current owners).
- `plannedEndDate` (string): YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string): YYYY-MM-DD.
- `releaseId` (string, required): Release id, code (RE-44) or exact name.
- `state` (string): The state to set, as the project names it (e.g. "In-progress", "Completed"). An unknown state is refused with the valid ones listed.

### `sprint_update` (~322 tokens)

Update or complete a sprint (SimplifyQA)

Change or COMPLETE a SimplifyQA sprint. Read sprints with sqa_query (collection "sprints"). Pass `sprintId` (id, code, or exact name) and either `close:true` (sets the completed state and the actual end date) or `state`, and/or name, dates, description, estimatedEffort, ownerIds. It reads the sprint back and reports the stored state. Only an admin user can edit a sprint in SimplifyQA, and its editor refuses to complete a sprint that still has new / pending stories, tasks or defects (not checked here).

Input parameters:

- `actualEndDate` (string): YYYY-MM-DD.
- `actualStartDate` (string): YYYY-MM-DD.
- `close` (boolean): true = close it: the project's completed-type state (Completed / Released / Closed) and the actual end date. Use this for "close release RE-44".
- `description` (string)
- `estimatedEffort` (number)
- `name` (string): New name (3–500 characters).
- `ownerIds` (array): Owner user ids (replaces the current owners).
- `plannedEndDate` (string): YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string): YYYY-MM-DD.
- `sprintId` (string, required): Sprint id, code or exact name.
- `state` (string): The state to set, as the project names it (e.g. "In-progress", "Completed"). An unknown state is refused with the valid ones listed.

### `release_create` (~259 tokens)

Create a release (SimplifyQA)

Create a SimplifyQA release in the connected project — what Releases → Create Release does — and return its key (RE-xx). Needs `name`, `plannedStartDate`, `plannedEndDate` (YYYY-MM-DD) and `estimatedEffort` (hours). The state defaults to New and the owner to the connected user (SimplifyQA requires one). A release with the same name is refused. It reads the release back. Only an admin user can create releases. Use the returned RE-xx as `releaseId` for runs, schedules and pipelines, and create sprints with sprint_create.

Input parameters:

- `description` (string)
- `estimatedEffort` (number, required): Estimated effort in hours (e.g. 2).
- `name` (string, required): Name (3–500 characters).
- `owners` (array): Owners: emails, names, user ids or "me". Default: the connected user (SimplifyQA requires at least one owner).
- `plannedEndDate` (string, required): YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string, required): YYYY-MM-DD.
- `state` (string): Defaults to the project's first state (New). An unknown state is refused with the valid ones listed.

### `sprint_create` (~283 tokens)

Create a sprint under a release (SimplifyQA)

Create a SimplifyQA sprint under an existing release and return its key (SP-xx). Needs `releaseId` (id, code like RE-44, or exact name — create the release first with release_create), `name`, `plannedStartDate`, `plannedEndDate` (YYYY-MM-DD) and `estimatedEffort` (hours). The state defaults to New and the owner to the connected user. A sprint with the same name in that release is refused; dates outside the release's are warned about. It reads the sprint back. Only an admin user can create sprints.

Input parameters:

- `description` (string)
- `estimatedEffort` (number, required): Estimated effort in hours (e.g. 2).
- `name` (string, required): Name (3–500 characters).
- `owners` (array): Owners: emails, names, user ids or "me". Default: the connected user (SimplifyQA requires at least one owner).
- `plannedEndDate` (string, required): YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string, required): YYYY-MM-DD.
- `releaseId` (string, required): The release this sprint belongs to: id, code (RE-44) or exact name.
- `state` (string): Defaults to the project's first state (New). An unknown state is refused with the valid ones listed.

### `release_delete` (~169 tokens)

Delete a release (SimplifyQA)

Delete a SimplifyQA release (Releases → Delete). TWO-STEP: call with `releaseId` (id, code like RE-45, or exact name) and no `confirm` to PREVIEW — it lists everything still linked (its sprints, stories, defects, tasks, execution plans, pipelines, schedules, other projects using it) and deletes nothing. Show that to the user, and call again with `confirm:true` ONLY after the user explicitly says to delete. A release that anything still uses is refused even with confirm. Only an admin user can delete a release.

Input parameters:

- `confirm` (boolean): true on the SECOND call, only after the user explicitly said to delete.
- `releaseId` (string, required): Release id, code (RE-45) or exact name.

### `sprint_delete` (~161 tokens)

Delete a sprint (SimplifyQA)

Delete a SimplifyQA sprint (Sprints → Delete). TWO-STEP: call with `sprintId` (id, code like SP-64, or exact name) and no `confirm` to PREVIEW — it lists everything still linked (stories, defects, tasks, execution plans, pipelines, schedules) and deletes nothing. Show that to the user, and call again with `confirm:true` ONLY after the user explicitly says to delete. A sprint that anything still uses is refused even with confirm. Only an admin user can delete a sprint.

Input parameters:

- `confirm` (boolean): true on the SECOND call, only after the user explicitly said to delete.
- `sprintId` (string, required): Sprint id, code (SP-64) or exact name.

### `object_parameterize` (~362 tokens)

Parameterize an object locator (SimplifyQA)

Turn part of a saved step's OBJECT locator into a "Parameter of object", as the SimplifyQA editor does: e.g. step 7 clicks the object whose locator is //a[normalize-space()='PIM'] — pass `replace:"PIM"`, `parameterName:"menu_name"` and the locator becomes //a[normalize-space()='{{<id>}}'], the step shows menu_name under "Parameter of object", and the test-data cell holds PIM. The recorder cannot do this itself. WITHOUT `confirm:true` it only reports what would change. The object is SHARED: other steps and test cases that use it will resolve the same parameter, so they need a value for it too. Reads the test data back and says whether the value is stored.

Input parameters:

- `confirm` (boolean): true = write it. Omit to preview.
- `locator` (string): Only rewrite the locator with this name (e.g. "Xpath by Role and Name"). Default: every locator containing the text.
- `parameterName` (string, required): Name of the parameter, e.g. menu_name. Created if it does not exist.
- `replace` (string): The text inside the locator to turn into the parameter, when it differs from `value`.
- `step` (integer, required): 1-based number of the step whose object holds the locator.
- `tcId` (string, required): Test case id or code, e.g. TC-12862.
- `value` (string): The value for the test-data cell, e.g. PIM. Also the locator text to replace unless `replace` is given.
- `versionId` (string): A non-current version of the test case (id or name like v2.0).

### `defect_update` (~862 tokens)

Update a defect (state, assignee, environment, type, feature, dates, linkages, attachments, …)

Change an existing DEFECT the way the SimplifyQA defect form does, then READ IT BACK and report each change. Pass `defectId` (id, code like DE-61, or exact name) and only what to change:
\- `storyId` — the form's USER STORY field (story id or key, e.g. US-25; "none" clears it). This is NOT a Linkages row.
\- `testCases` — the form's TEST CASE field: test cases to ADD, each "TC-41" or with its version "TC-41:v1.0" (no version = the test case's current one, and the answer says which). The defect then shows in each test case's linked defects — checked after saving. `removeTestCases` takes some out; `clearTestCases:true` empties the field.
\- `state`, `priority`, `severity` (the project's own values; an unknown one is refused with the valid ones listed), `assignee` (email, name, user id or "me") or `unassign:true`, `releaseId` / `sprintId` (id, code or name; "none" clears), `name`, `description`.
\- `environment`, `executionType` (alias `type`), `featureId`, `plannedStartDate`, `plannedEndDate` — the rest of the form ("none" clears one). Environment / Type are checked against the project's own list (or the form's: Development / QA / UAT, Manual / Automation).
\- `linkages` — LINKAGES saved from the defect's side: [{ destType, destId, linkType }].
\- `attachments` — files to attach to the defect ([{ filePath }]).
Needs the add_defect privilege.

Input parameters:

- `assignee` (string): Email, name, numeric user id or "me".
- `attachments` (array): ATTACHMENTS: files to attach to the defect (max 20 MB each). To remove or download one later: attachment_delete / attachment_download with entityType "defect".
- `clearTestCases` (boolean): true = empty the TEST CASE field.
- `defectId` (string, required): Defect id, code (DE-61) or exact name.
- `description` (string)
- `environment` (string): ENVIRONMENT: one of the project's own list, or the form's (Development, QA, UAT). An unknown value is refused with the valid ones.
- `executionType` (string): TYPE (the form's Execution Type): Manual or Automation (or the project's own list).
- `featureId` (string): FEATURE: a feature of this project — id, business key (FT-248) or exact name.
- `linkages` (array): LINKAGES, saved from the DEFECT's side (the form's Linkages section). A link that already exists is left as it is.
- `name` (string): New name (at least 3 characters).
- `plannedEndDate` (string): PLANNED END DATE, YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string): PLANNED START DATE, YYYY-MM-DD.
- `priority` (string)
- `releaseId` (string): Release: id, code (RE-44) or exact name; "none" clears it (and the sprint).
- `removeTestCases` (array): Test cases to take out of the TEST CASE field.
- `severity` (string)
- `sprintId` (string): Sprint: id, code (SP-1) or exact name; it must belong to the defect's release. "none" clears it.
- `state` (string)
- `storyId` (string): USER STORY field: story id or key (US-25); "none" clears it.
- `testCases` (array): TEST CASE field — test cases to add: "TC-41" or "TC-41:v1.0".
- `type` (string): Same as executionType — the form's TYPE field.
- `unassign` (boolean): true = clear the assignee.

### `defect_create` (~827 tokens)

Log a defect (create)

Log a new DEFECT in the connected project — what Defect Management → Create Defect does — and return its key (DE-xx). Only `name` is required; state and priority default to the project's own default values, and the answer lists what was defaulted. Optional: `description`, `severity`, `category` (the project's own values; an unknown one is refused with the valid ones listed), `assignee` (email, name, user id or "me"), `releaseId` / `sprintId` (id, code or name), `storyId` (the USER STORY field: id or key, e.g. US-25), `testCases` (the TEST CASE field: "TC-41" or "TC-41:v1.0" — the test case then lists the defect, checked after saving), `module` (default: the project's Default module), `estimatedEffort`, `customFields` ({ key: value } — needed when the project marks custom fields mandatory), and the rest of the form: `environment`, `executionType` (alias `type`: Manual / Automation), `featureId`, `plannedStartDate` / `plannedEndDate` (YYYY-MM-DD), `linkages` ([{ destType, destId, linkType }], saved from the defect's side) and `attachments` ([{ filePath }]). Environment / Type are checked against the project's own list (or the form's: Development / QA / UAT, Manual / Automation); a bad value refuses the call before anything is created. A defect with the same name is refused. Reads the defect back. Needs the add_defect privilege. To log a defect FROM a failed execution step (evidence pre-filled), use defect_create_from_step instead; to change one later, defect_update.

Input parameters:

- `assignee` (string): Email, name, numeric user id or "me". Default: unassigned.
- `attachments` (array): ATTACHMENTS: files to attach to the defect (max 20 MB each). To remove or download one later: attachment_delete / attachment_download with entityType "defect".
- `category` (string)
- `customFields` (object): Custom field values { "<field key>": value }.
- `description` (string)
- `environment` (string): ENVIRONMENT: one of the project's own list, or the form's (Development, QA, UAT). An unknown value is refused with the valid ones.
- `estimatedEffort` (number)
- `executionType` (string): TYPE (the form's Execution Type): Manual or Automation (or the project's own list).
- `featureId` (string): FEATURE: a feature of this project — id, business key (FT-248) or exact name.
- `linkages` (array): LINKAGES, saved from the DEFECT's side (the form's Linkages section). A link that already exists is left as it is.
- `module` (string): Module name, code or id. Default: the project's Default module.
- `name` (string, required): Defect name (3–500 characters).
- `plannedEndDate` (string): PLANNED END DATE, YYYY-MM-DD, on or after the start.
- `plannedStartDate` (string): PLANNED START DATE, YYYY-MM-DD.
- `priority` (string)
- `releaseId` (string): Release: id, code (RE-44) or exact name.
- `severity` (string)
- `sprintId` (string): Sprint: id, code (SP-1) or exact name; it must belong to the release.
- `state` (string)
- `storyId` (string): USER STORY field: story id or key (US-25).
- `testCases` (array): TEST CASE field: "TC-41" or "TC-41:v1.0".
- `type` (string): Same as executionType — the form's TYPE field.

### `defect_create_from_step` (~400 tokens)

Log a defect from a failed execution step

Log a DEFECT from a FAILED step of an execution — what "Log Defect" in the execution report does — and link it to that step. Pass `executionId` (EX-170 or 170) and `step` (the step number in the report; it must have failed). If the execution ran several test cases, also pass `tc`. The defect is pre-filled from the report: test case + version, steps to replicate up to the failure, execution, environment, browser, expected vs actual and the error message, and the step's screenshots; its release / sprint / module come from the execution / test case. Optional: `name` (default "TC-41 step 7 failed: … (EX-170)"; a defect with that name already existing is refused — link it with defect_link_step instead), `description` (extra notes), `state` / `priority` / `severity` (the project's own values, default = the project's defaults), `assignee` (email, name, user id or "me"). Needs the add_defect privilege. Returns the defect key (DE-xx); the test case then lists it too. To attach a step to a defect that already exists, use defect_link_step.

Input parameters:

- `assignee` (string): Email, name, numeric user id or "me".
- `description` (string): Extra notes added to the defect description.
- `executionId` (string, required): Execution id or code: EX-170 or 170.
- `name` (string): Defect name (3–500 characters).
- `priority` (string)
- `severity` (string)
- `state` (string)
- `step` (integer, required): Step number as shown in the report; it must be a FAILED step.
- `tc` (string): Test case id or code (TC-41) — only when the execution ran several test cases.

### `defect_link_step` (~239 tokens)

Link a failed execution step to an existing defect

Link a FAILED step of an execution to a defect that ALREADY EXISTS (e.g. DE-60) — what "link defect" on the report step does — and make sure the step's test case + version is on the defect's TEST CASE field, so the link shows from the defect, the test case and the execution report. Pass `executionId` (EX-170 or 170), `step` (must have failed) and `defectId` (id, code or exact name); `tc` only when the execution ran several test cases. Linking a step that is already linked changes nothing. To create a new defect from the step, use defect_create_from_step.

Input parameters:

- `defectId` (string, required): The existing defect: id, code (DE-60) or exact name.
- `executionId` (string, required): Execution id or code: EX-170 or 170.
- `step` (integer, required): Step number as shown in the report; it must be a FAILED step.
- `tc` (string): Test case id or code (TC-41) — only when the execution ran several test cases.

### `test_plan` (~412 tokens)

Create / change / delete a SimplifyQA test plan

Manage SimplifyQA TEST PLANS (the Test Plan folders under Test Execution). Read them with sqa_query collection "testPlans". Actions:
\- action:"create" — needs `name`; optional `parentId` (a test plan id) makes it a sub-folder.
\- action:"rename" — needs `testPlanId` and `name`.
\- action:"add" — needs `testPlanId` and `suiteIds` and/or `tcIds`; ones already in the test plan are skipped.
\- action:"remove_suite" — needs `testPlanId` and `suiteId`.
\- action:"remove_testcase" — needs `testPlanId` and `tcId` (optional `versionId` when the folder has several versions of it). Removes ONLY that test case; the plan is re-read to confirm. Suites, other test cases and sub-folders are untouched.
\- action:"delete" — needs `testPlanId`. TWO-STEP: the first call only previews (it deletes every folder below it too); call again with `confirm:true` ONLY after the user explicitly says to delete.

Input parameters:

- `action` (string, required): What to do.
- `confirm` (boolean): delete: true on the SECOND call, only after the user explicitly said to delete.
- `name` (string): create / rename: the name.
- `parentId` (string): create: parent test plan id (omit for a top-level one).
- `suiteId` (string): remove_suite: the suite to take out.
- `suiteIds` (array): add: suite ids or codes.
- `tcId` (string): remove_testcase: the test case to take out (id or code).
- `tcIds` (array): add: test case ids or codes.
- `testPlanId` (string): Every action except create: test plan id or code.
- `versionId` (string): remove_testcase: only when the folder holds several versions of that test case.

### `pipeline` (~499 tokens)

Create / change / delete / run a SimplifyQA pipeline

Manage SimplifyQA PIPELINES. Read them with sqa_query collection "pipelines". Actions:
\- action:"create" — needs `name`, `pipelineType` (TC or SU), `parentId` (the test case or suite), `mode` (local / remote / cloud), `releaseId` and `sprintId` (SimplifyQA requires both — ASK if unknown); optional `agentId`, `environment`, `browser` (TC), `description`.
\- action:"update" — needs `pipelineId`; any of `name`, `description`, `releaseId`, `sprintId`, `environment`, `agentId`, `mode`.
\- action:"delete" — needs `pipelineId`. TWO-STEP: the first call only previews; call again with `confirm:true` ONLY after the user explicitly says to delete.
\- action:"run" — needs `pipelineId`; call ONLY when the user explicitly asked to run it.
\- action:"run_status" / "stop" — need `executionId` (from run).

Input parameters:

- `action` (string, required): What to do.
- `agentId` (string): create / update: agent id (local_agents / remote_agents).
- `browser` (string): create: browser for the WEB test cases — the test case, or every WEB test case in the suite (default chrome). A CLOUD pipeline is headless: only Chrome Headless, Firefox Headless or Edge Headless exi…
- `confirm` (boolean): delete: true on the SECOND call, only after the user explicitly said to delete.
- `description` (string): create / update.
- `environment` (string): create / update: environment name or key (default general).
- `executionId` (string): run_status / stop: the execution id from run.
- `mode` (string): create / update: where it runs.
- `name` (string): create / update: pipeline name.
- `parentId` (string): create: the test case or suite id / code.
- `pipelineId` (string): update / delete / run: pipeline id or code.
- `pipelineType` (string): create: TC (test case) or SU (suite).
- `releaseId` (string): create / update: release id (required to create).
- `sprintId` (string): create / update: sprint id (required to create).

### `tc_list_environments` (~101 tokens)

List environments configured for the connected project

List every environment configured for the currently connected project (e.g. general, staging, production). Testdata is stored PER ENVIRONMENT — each env has its own iteration rows. ALWAYS call this before tc_get_testdata / tc_generate_testdata, show the user the options, and ASK which env they want to generate testdata for. Never assume. The value to pass onward as `environmentType` is the `key` field on each returned env.

### `tc_get_testdata` (~556 tokens)

Read the current testdata template for a test case

Fetch the default iteration (template row) for TC `tcId` in a specific environment — the parameter list plus the CURRENT seed values. Testdata is per-env: seeds may differ across envs. `environmentType` is REQUIRED — this tool refuses when it is omitted, since silently guessing an env previously caused false "testdata not found" results. FIRST call tc_list_environments and ask the user which env they want. Then read the template here, and use the seeds + the test case's steps (from tc_get) to reason about realistic values before calling tc_generate_testdata.

VERSIONS: SimplifyQA TCs can have multiple versions with different params/seeds. When the TC has more than one version and `versionId` is omitted, this tool REFUSES and lists the available versions — ASK the user which one, then call again with `versionId`. Pass `versionId: ''` to accept the TC's currently-selected version. Single-version TCs are read directly.

FUNCTIONS: if a step in this TC calls a reusable FUNCTION, the `parameters` array (and the row list in this response's text) includes ONE extra row for it — a row whose "seed" is the function's NAME + VERSION, not its testdata (a called function's testdata is its own separate tc_get_testdata call, never guessed or fabricated here). It is a normal row in the SAME table as the TC's own parameters — do not pull it out into separate prose afterward. When one or more functions were called, this response ALSO ends with an explicit prompt listing each one and the exact tc_get_testdata args to fetch its testdata — ASK the user which (if any) they want BEFORE calling tc_get_testdata again for a function; do not fetch one unprompted, and do not skip the ask just because there is only one.

Input parameters:

- `entityType` (string): 'TC' (default) = `tcId` is a test case. 'FN' = `tcId` is a reusable FUNCTION id — reads/saves the FUNCTION's own testdata iterations.
- `environmentType` (string): Env `key` (from tc_list_environments). REQUIRED — this tool refuses when omitted. Ask the user which env before reading testdata.
- `tcId` (string, required): Test case id (or business key like TC_123). With entityType "FN": the function id.
- `versionId` (string): Version to read testdata for (an id from the TC's `versions[]`). Omit to trigger the ASK-user prompt when the TC has multiple versions. Pass '' to accept the TC's currently-selected version without p…

### `tc_generate_testdata` (~660 tokens)

Save generated testdata rows to a test case

Persist up to 20 testdata rows for TC `tcId` into a SPECIFIC environment. Testdata is stored per environment — rows saved here only affect the env you pass. WORKFLOW: (1) call tc_list_environments and ASK the user which env; (2) call tc_get_testdata with that env to read seeds; (3) call this tool with the SAME `environmentType`. `environmentType` is REQUIRED here — this tool refuses when it is omitted. Two ways to feed values:
  1\) Model-generated — pass `rows: [{paramName: value}, ...]`. Call tc_get_testdata first for the parameter names + seeds, tc_get for step context, then produce rows that fit the flow.
  2\) Formula-driven — pass `formulas: {paramName: {name, args?}}` (names from tc_list_formulas). Each formula is evaluated per row by the SimplifyQA desktop AGENT (the same engine the UI and the executor use, so every formula from tc_list_formulas works, including nested ones) and both the value and the source `=NAME(...)` expression are stamped. The agent must be running (QA_MCP_URL). For nested / custom formulas pass `expression` instead of `name`+`args`. Use `count` to say how many rows, or provide `rows` for constant columns; mixing is fine (formulas win over row values for the same param).
Rows are appended as new iterations; they do not become the default. Hard cap: 20 rows.

VERSIONS: SimplifyQA TCs can have multiple versions with different params. When the TC has more than one version and `versionId` is omitted, this tool REFUSES and lists the available versions — ASK the user which one, then call again with `versionId`. Pass `versionId: ''` to accept the TC's currently-selected version.

Input parameters:

- `count` (integer): How many rows to generate when using formulas without explicit rows. Ignored if rows is set.
- `entityType` (string): 'TC' (default) = `tcId` is a test case. 'FN' = `tcId` is a reusable FUNCTION id — reads/saves the FUNCTION's own testdata iterations.
- `environmentType` (string): Env `key` (from tc_list_environments). REQUIRED — this tool refuses when omitted. Ask the user which env before generating.
- `formulas` (object): Per-column formula assignments applied to every row. Outer keys are param names from tc_get_testdata. Wins over rows[i] for the same key.
- `rows` (array): Rows keyed by param name (from tc_get_testdata). 1..20 rows. Omit when using formulas + count.
- `tcId` (string, required): Test case id (or business key like TC_123). With entityType "FN": the function id.
- `versionId` (string): Version to save testdata into (an id from the TC's `versions[]`). Omit to trigger the ASK-user prompt when the TC has multiple versions. Pass '' to accept the TC's currently-selected version without…

### `tc_update_testdata` (~301 tokens)

Update the existing test data (default iteration) of a test case

UPDATE the test data a run actually uses — the DEFAULT iteration (ITR-1) — instead of appending a new row. Use this for "change/set/fix the test data", "add a formula to the test data", or whenever a value or formula must apply to the NEXT run. (tc_generate_testdata APPENDS iterations; an appended row never becomes the default, so a formula saved there does not affect the run.)

Each cell takes a literal `value` or a `formula` ({ name, args? } from tc_list_formulas, or a full `expression` — nested formulas are supported). Formulas are evaluated by the SimplifyQA desktop agent; the evaluated value AND the canonical =NAME(...) expression are stored, and the executor re-evaluates at run time. Unknown/invented names and unevaluatable formulas are rejected BEFORE anything is written. Only the named cells change — every other column keeps its value — and the row is read back.

Input parameters:

- `cells` (array, required): Cells to change. Only these are touched.
- `environmentType` (string, required): Env `key` from tc_list_environments. REQUIRED — test data is per environment.
- `tcId` (string, required): Test case id or business key (e.g. TC_123).
- `versionId` (string): Version id from the TC's versions[]. Omit on a single-version TC; pass '' to accept the current one.

### `suite_get_testdata` (~158 tokens)

Read a suite's SUITE-LEVEL test data

Read the SUITE-LEVEL test-data iterations of suite `suiteId` (SU-24) in an environment. Suite-level test data is a SEPARATE store from the member test cases' own test data. When the user says "SU-24 test data", ALWAYS use this — never tc_get_testdata on a member test case. `environmentType` is REQUIRED: call tc_list_environments, show the keys, and ASK which env. The result lists every iteration (name, default marker, parameter=value cells).

Input parameters:

- `environmentType` (string, required): Environment key from tc_list_environments (e.g. general, general_1).
- `suiteId` (string, required): Suite id or business key (SU-24).

### `suite_copy_testdata` (~241 tokens)

Copy a SUITE-LEVEL test-data row and save it on the suite

Copy ONE existing suite-level row of suite `suiteId` into a NEW suite-level row and save it. Use for "copy ITR-1 into ITR-2 in SU-24's test data and save". The copy is written to the SUITE-LEVEL test data ONLY — member test cases' own test data is NEVER touched. `from` names the source row (default: the suite default row, normally ITR-1); `name` names the new row (default: the next free ITR-N). The tool then reads the suite's test data back and confirms the new row exists. Refuses a duplicate row name.

Input parameters:

- `environmentType` (string, required): Environment key from tc_list_environments (e.g. general, general_1).
- `from` (string): Source iteration name (e.g. "ITR-1") or id. Default: the suite default row.
- `name` (string): Name for the new row (e.g. "ITR-2"). Default: next free ITR-N.
- `suiteId` (string, required): Suite id or business key (SU-24).

### `testdata_delete_iterations` (~228 tokens)

Delete test-data iteration rows (test case or suite level)

Delete one or more test-data iteration rows by NAME (e.g. "ITR-2") or id. Works at TEST CASE level (`entityType:"TC"` + `tcId`) and at SUITE level (`entityType:"SU"` + `suiteId`). The DEFAULT row is refused — to replace the default, first make another row the default with testdata_set_default_iteration. Use this to remove rows created by mistake. It reads the rows back after deleting and reports what remains.

Input parameters:

- `entityType` (string): TC = a test case's own test data; SU = suite-level test data. Default TC.
- `environmentType` (string, required): Environment key from tc_list_environments (e.g. general, general_1).
- `iterations` (array, required): Iteration names (e.g. ["ITR-2"]) or ids to delete.
- `suiteId` (string): Suite id / SU-24 (required when entityType is SU).
- `tcId` (string): Test case id / TC-123 (required when entityType is TC).

### `testdata_set_default_iteration` (~280 tokens)

Make a test-data iteration the default (test case or suite level)

Make one iteration row the DEFAULT of an environment — the row a run uses — e.g. "make ITR-2 the default for SU-23 in General". Works at TEST CASE level (`entityType:"TC"` + `tcId`) and SUITE level (`entityType:"SU"` + `suiteId`). Pass the iteration by NAME (e.g. "ITR-2") or id. The previous default simply stops being the default (it is NOT deleted — delete it afterwards with testdata_delete_iterations if wanted); other environments' defaults are kept. It reads the test data back and reports the new default; asking for the row that already is the default changes nothing.

Input parameters:

- `entityType` (string): TC = a test case's own test data; SU = suite-level test data. Default TC.
- `environmentType` (string, required): Environment key from tc_list_environments (e.g. general, general_1) — each environment has its own default.
- `iteration` (string, required): The iteration to make the default: its name (e.g. "ITR-2") or id.
- `suiteId` (string): Suite id / SU-23 (required when entityType is SU).
- `tcId` (string): Test case id / TC-123 (required when entityType is TC).

### `column_preference` (~250 tokens)

Read or change list-view COLUMN preferences (SimplifyQA)

Read or change which columns a LIST VIEW shows for THIS user — the same write as ticking a column in the UI's Column Preference menu. Supported lists: epic, feature, userstory, testcase (Test Case list), suite (Suite test-case list), scenario (Test plan test-case list) and executionplan (Execution Plan test-case list, including "Execution Type"). action "get" returns the visible column keys of each list; action "set" enables or disables `column` (a label like "Execution Type", or its key like "executionType") on every list in `lists`, then reads the preferences back to confirm. The change applies to the UI after a refresh.

Input parameters:

- `action` (string, required): get = read visible columns; set = enable/disable a column.
- `column` (string): action "set": column LABEL ("Created On") or key ("createdAt").
- `enabled` (boolean): action "set": true to show the column (default), false to hide it.
- `lists` (array, required): Which list views to touch. testcase = Test Cases; suite = Suite test cases; scenario = Test plan test cases; executionplan = Execution Plan test cases.

### `attachment_add` (~222 tokens)

Attach a file/screenshot to an epic, feature, user story or defect (SimplifyQA)

Upload ONE file and attach it to an existing backlog item, then read the item's attachments back to confirm it is there (it will appear in the item's Attachments section in the UI). Pass the file as a LOCAL `filePath` (preferred — e.g. the screenshot path the user shared), or as `base64` + `fileName` when only the bytes are available. Max 20 MB.

Input parameters:

- `base64` (string): File content as base64 (when there is no local path). Requires fileName.
- `contentType` (string): MIME type; inferred from the extension when omitted.
- `entityType` (string, required): Which backlog item to attach to (a defect too).
- `fileName` (string): Name to store the attachment under (default: the file's own name).
- `filePath` (string): Absolute path of the file to upload (read on this machine).
- `itemId` (string, required): Item id or business key (EP-66, FT-266, US-1326, DE-75).

### `attachment_delete` (~108 tokens)

Remove an attachment from an epic, feature, user story or defect (SimplifyQA)

Remove ONE attachment from an existing backlog item by its id or stored/original file name, then read the item's attachments back to confirm it is gone. Use it to undo a wrong upload.

Input parameters:

- `attachment` (string, required): Attachment id, or its original/stored file name.
- `entityType` (string, required): Which backlog item the attachment belongs to.
- `itemId` (string, required): Item id or business key (EP-66, FT-266, US-1326, DE-75).

### `attachment_download` (~301 tokens)

Download an attachment of an epic, feature, user story or defect (SimplifyQA)

DOWNLOAD attachments of an epic, feature, user story or defect from SimplifyQA to a local folder — fetched from SimplifyQA with the user's login (not copied from a local file). Pass `entityType` + `itemId` (EP-69, FT-269, US-1330, DE-75). If the item has ONE attachment it is downloaded; if it has SEVERAL and you pass no choice, the tool LISTS them (name, size, id) — show that list to the user and call again with `attachments` (names or ids, one or several) or `all:true`. `outDir` is the folder to save into (default "./exports"; created if missing). The answer gives each saved path, file name and size and says whether the size matches what SimplifyQA reports; an existing file is never overwritten (a " (1)" is added).

Input parameters:

- `all` (boolean): true = download every attachment of the item.
- `attachments` (array): Which attachments: file names or ids (one or several). Omit to be shown the list when there is more than one.
- `entityType` (string, required): Which backlog item the attachment belongs to.
- `itemId` (string, required): Item id or business key (EP-69, FT-269, US-1330, DE-75).
- `outDir` (string): Folder to save into. Default "./exports".

### `project_create` (~84 tokens)

Create a project (SimplifyQA)

Create a new PROJECT with a name and description. The new project is returned with its id and business code (PR-x), and is read back to confirm. Use qa_switch_project to work in it afterwards.

Input parameters:

- `description` (string): Project description.
- `name` (string, required): Project name.
- `users` (array): Optional numeric userIds to add as project members.

### `project_delete` (~116 tokens)

Delete a project (SimplifyQA)

DESTRUCTIVE. Delete ONE project by id or code (e.g. "5" or "PR-7"). TWO-STEP: call without `confirm` to get a preview of the project that will be deleted; show it and ASK the user; only then call again with `confirm:true`. It removes the project and everything inside it.

Input parameters:

- `confirm` (boolean): Set true only after the user explicitly confirms.
- `projectId` (string, required): Project id or code (e.g. "5", "PR-7").

### `project_user_add` (~197 tokens)

Add or invite a user to a project (SimplifyQA)

Add a person to a project with a role — the admin Project screen's "Invite Users". The email is resolved to an existing user; when nobody has it the user is INVITED (created and the invitation email sent) unless `invite:false`. Existing members are preserved — the project's member list is merged, never replaced — and the membership is read back to confirm. Defaults to the connected project and to the project's QA role.

Input parameters:

- `email` (string, required): Email address of the person to add, e.g. someone@yopmail.com.
- `invite` (boolean): Invite the user when the email is unknown (default true). false = fail instead.
- `name` (string): Display name — used only when the user has to be invited.
- `projectId` (string): Project id. Defaults to the connected project.
- `roleId` (number): Role id inside that project. Default 1 (the QA role).

### `project_user_remove` (~109 tokens)

Remove a user from a project (SimplifyQA)

Remove ONE person from a project (their membership row only — the user account and the person's other projects are untouched). Identify them by `email` or `userId`; the remaining membership is read back to confirm and the removed list is reported. The project's other members are preserved.

Input parameters:

- `email` (string): Email of the person to remove.
- `projectId` (string): Project id. Defaults to the connected project.
- `userId` (number): Numeric user id (alternative to email).

### `environment_manage` (~296 tokens)

Create, update or delete a project environment (SimplifyQA)

Manage the project's ENVIRONMENTS (project configuration > Environments, next to General).
\- action:"create" — needs `name` (optional `key`, else generated exactly like the UI). Refused when that name already exists.
\- action:"update" — needs `environment` (current name or key) and the new `name` and/or `key`.
\- action:"delete" — needs `environment`. TWO-STEP: the first call only previews; call again with `confirm:true` ONLY after the user explicitly says to delete (the default General environment is refused).
Every write posts the WHOLE environment list to `/pm/fields/savefields`, exactly as the UI does, and is read back to confirm. A saved environment is selectable for executions, schedules, pipelines and execution plans, and the product provisions its own test data. List them with `sqa_query collection:"environments"`.

Input parameters:

- `action` (string, required): What to do.
- `confirm` (boolean): delete: true on the SECOND call, only after the user explicitly said to delete.
- `environment` (string): update / delete: the existing environment, by name or key.
- `key` (string): Optional environment key (used as `environmentType` in test data). Generated when omitted on create.
- `name` (string): create: the environment name (required). update: the NEW name (optional if only the key changes).

### `excel_import` (~394 tokens)

Import test cases / test data / plan entries from a spreadsheet (.xlsx, .csv, .tsv)

Bulk-import a spreadsheet into SimplifyQA — the MCP equivalent of the UI's Import.
\`kind:"testcases"` — one MANUAL test case per row. Recognised headers (case/spacing-insensitive): `name`/`title` (required), `description`, `steps` (one step per line, or `|` separated), `expected result`, `module`, `story`/`userstory`, `prerequisites`. A step column is prose, so the imported cases are MANUAL (automation needs real locators — record those).
\`kind:"testdata"` — one ITERATION per row for ONE test case: needs `tcId` + `environmentType`; every column is a parameter name (matched case-insensitively).
\`kind:"plan_entries"` — the first column is a test case code/id; needs `planId` (execution plan).
Reports what was created / added and every rejected row with its reason. `dryRun:true` parses + reports without writing. The first row is the header unless `headerRow:false`.

Input parameters:

- `dryRun` (boolean): Parse and report only — nothing is written.
- `environmentType` (string): testdata: env key from tc_list_environments (required).
- `filePath` (string, required): Absolute path to the .xlsx / .csv / .tsv file on this machine.
- `headerRow` (boolean): Treat the first row as headers (default true).
- `kind` (string, required): What to import.
- `module` (string): testcases: default module/folder id or name for rows without a module column.
- `planId` (string): plan_entries: the execution plan id/code.
- `storyRef` (string): testcases: default user story id/code for rows without a story column.
- `tcId` (string): testdata: the target test case (id or code).

### `action_template_backup` (~248 tokens)

Back up / verify / restore the Action catalogue (Object Templates)

Protects the project's ACTIONS (the Object Template lists: WEB Click / Enter Text / … plus custom methods) against a bad "Sync Actions" run, which SimplifyQA applies server-side and can replace a template's list.
\- action:"save" — writes a JSON snapshot of every action (name, display name, uniqueId, template, parameters) and reports the count per template. Do this BEFORE an AI/agent sync.
\- action:"verify" — compares a snapshot with the live catalogue and lists the actions missing per template. Read-only.
\- action:"restore" — re-CREATES the missing actions from the snapshot (never deletes or edits). Dry-run by default; pass `confirm:true` to write.
\`snapshotPath` is returned by save and accepted by verify/restore (default: the newest snapshot of this project).

Input parameters:

- `action` (string, required): What to do.
- `confirm` (boolean): restore: true to actually re-create the missing actions.
- `dryRun` (boolean): restore: report only (default true).
- `snapshotPath` (string): verify / restore: the JSON file written by save. Default: newest for this project.

### `tc_list_formulas` (~181 tokens)

List testdata formulas available in the current project

Return the formulas the connected project can use for testdata generation — DEFAULT prefabs (FIRST_NAME, LAST_NAME, COUNTRY_NAME, EMAIL_ID, PHONE_NUMBER, …) plus any CUSTOM formulas defined at customer or project scope. EVERY line starts with the NAME to pass as `name`; the parenthesised part after it is the human signature (it can differ — e.g. the name is EMAIL_ID while its signature reads EMAIL(...)), and `args:` lists the argument keys the formula accepts (matched case-insensitively). Feed a chosen `{name, args}` into `tc_generate_testdata.formulas` and that column is auto-filled fresh per row by the agent's formula engine. Use this when the user says "use a formula" / "generate an email" / "first name, phone, country…" / "list formulas".

### `task_update` (~460 tokens)

Update a task (planned dates, assignee, state, …)

Change an existing TASK — what the SimplifyQA editor does, then it READS THE TASK BACK and reports each change. Pass `taskId` (id, code like TA-3, or exact name) and only what to change: `plannedStartDate` / `plannedEndDate` (YYYY-MM-DD), `assignee` (email, name, user id or "me" — one that matches nobody is refused) or `unassign:true`, `state`, `priority` (the project's own values; an unknown one is refused with the valid ones listed), `releaseId` / `sprintId` (id, code or name; a sprint brings its release; "none" clears), `storyId` (the linked user story; "none" clears), `name`, `description`, `estimatedEffort`, `actualEffort`, `remainingEffort`. Needs the add_task privilege. A start date after the end date is refused — move the end date too.

Input parameters:

- `actualEffort` (number)
- `assignee` (string): Who to assign it to: email (rohini.k@simplify3x.com), name, numeric user id, or "me".
- `description` (string)
- `estimatedEffort` (number)
- `name` (string): New name (at least 3 characters).
- `plannedEndDate` (string): YYYY-MM-DD.
- `plannedStartDate` (string): YYYY-MM-DD.
- `priority` (string)
- `releaseId` (string): Release: id, code (RE-44) or exact name; "none" clears it (and the sprint).
- `remainingEffort` (number)
- `sprintId` (string): Sprint: id, code (SP-1) or exact name; it must belong to the task's release. "none" clears it.
- `state` (string)
- `storyId` (string): Linked user story: id or key (US_123); "none" unlinks it.
- `taskId` (string, required): Task id, code (TA-3) or exact name.
- `unassign` (boolean): true = clear the assignee.

### `task_create` (~409 tokens)

Create a task

Create a TASK in the connected project — what Tasks → Create Task does — and return its key (TS-xx / TA-xx). Needs `name` and `estimatedEffort` (hours); everything else is optional and DEFAULTED, and the answer lists what was defaulted: type / state / priority = the project's own default values, planned dates = the sprint's (else the release's, else today). Optional: `description`, `assignee` (email, name, user id or "me" — one that matches nobody is refused), `releaseId` / `sprintId` (id, code or exact name; a sprint brings its release and must belong to the release named), `storyId` (the user story it belongs to: id or key), `type`, `state`, `priority`, `plannedStartDate` / `plannedEndDate` (YYYY-MM-DD). A task with the same name in the project is refused. Reads the task back. Needs the add_task privilege. Change it later with task_update.

Input parameters:

- `assignee` (string): Email, name, numeric user id or "me". Default: unassigned.
- `description` (string)
- `estimatedEffort` (number, required): Estimate in hours.
- `name` (string, required): Task name (2–500 characters).
- `plannedEndDate` (string): YYYY-MM-DD.
- `plannedStartDate` (string): YYYY-MM-DD.
- `priority` (string)
- `releaseId` (string): Release: id, code (RE-44) or exact name.
- `sprintId` (string): Sprint: id, code (SP-1) or exact name; it must belong to the release.
- `state` (string)
- `storyId` (string): User story it belongs to: id or key (US_123).
- `type` (string): Task type — one of the project's own; default: the project's default type.

### `heal_plan` (~343 tokens)

Plan a heal for a failed test case (read-only)

Replays a failed test case live, captures the DOM at the failing step, and returns a REVIEWABLE heal plan: objects (locators + properties), per-step actions, parameters, and the test data of the failing iteration only. This call never writes — apply it with `heal_apply({ planId })`.

Use it when a test failed for a reason the healer may fix (locator/object changed, wrong action, unresolved `${param}`, bad test-data value). It also reports a diagnosis when the failure is NOT healable (app bug, environment, bad business data), with the reason.

Rules baked in: the shared action catalog is never modified, shared parameters are never renamed (create + rebind instead), and only the iteration that failed may have test data patched.

Input parameters:

- `domains` (array): Limit which domains may change (default: all). e.g. ["parameter","testdata"] to skip locator churn.
- `maxAttemptsPerStep` (integer): Replay retries at the failing step. Default 3.
- `runId` (string): Specific failed run. Omit to use the latest failed run.
- `tcId` (string, required): The failing test case id (TC-123).
- `testFamily` (string): TEST ONLY: family to report alongside testProposals (default object_state).
- `testProposals` (array): TEST ONLY (needs QA_HEAL_TEST_HOOK=1): plan these raw proposals instead of calling heal_propose. The full validation/apply pipeline runs exactly as in production; only the browser-driven proposal ste…
- `url` (string): Override start URL when the test case has no navigate step.

### `heal_apply` (~161 tokens)

Apply a heal plan (creates a NEW version)

Applies a plan from `heal_plan` as ONE new test-case version: objects first, then step/action bindings, then the failing iteration's test data. The current version is never edited, so a running execution is not affected. `mode:"apply_and_verify"` also re-runs the test case and reports `verified` only when the healed step passes WITHOUT falling back to another locator.

Refuses a stale plan (the test case moved to a different version since planning) — re-run heal_plan then.

Input parameters:

- `confirmSharedObject` (boolean): Required when the plan changes an object also used by other test cases (blast radius non-empty).
- `mode` (string): Default 'apply'.
- `planId` (string, required): planId returned by heal_plan.

### `heal_status` (~45 tokens)

Read a heal plan and its result

Returns the stored plan for a planId and, once applied, the apply report (version, verified, partial).

Input parameters:

- `planId` (string, required): planId returned by heal_plan.

### `tc_heal` (~326 tokens)

Diagnose and heal a failed test-case run

One-shot alias for heal_plan + heal_apply. Default `mode:"suggest"` only diagnoses and proposes — it writes NOTHING. Pass `mode:"apply"` (new version) or `mode:"apply_and_verify"` (new version + re-run) to write.

Covers objects (locators/properties), actions (per step only — the catalog is never modified), parameters, and the test data of the failing iteration. Every response carries a classification and rationale, even when the failure is not healable (app bug, bad business data, environment).

Input parameters:

- `confirmSharedObject` (boolean): Required when applying a plan that changes an object used by other test cases.
- `domains` (array): Limit which domains may change (default: all).
- `maxAttemptsPerStep` (integer): Replay retries at the failing step. Default 3.
- `mode` (string): Default 'suggest' (no writes). 'apply' persists a NEW version; 'apply_and_verify' also re-runs.
- `runId` (string): Specific failed run to heal against.
- `tcId` (string, required): The failing test case id.
- `testFamily` (string): TEST ONLY: family to report alongside testProposals (default object_state).
- `testProposals` (array): TEST ONLY (needs QA_HEAL_TEST_HOOK=1): plan these raw proposals instead of calling heal_propose. The full validation/apply pipeline runs exactly as in production; only the browser-driven proposal ste…
- `url` (string): Override start URL for the replay.

### `report_download` (~365 tokens)

Download PDF reports for a test case or suite execution

Generate and SAVE the PDF execution reports the SimplifyQA UI offers.
  • target "testcase" — report types: `detailed`, `summary` (pick one or both).
  • target "suite" — report types: `suite` (overall suite report), `detailed` (one detailed report per test case in the suite), `summary` (one summary report per test case). Pick one, several or all.
\`ref` is the test case id/key (TC_123) or the suite NAME / id. If the user did NOT say which report type(s) they want, call WITHOUT `reportTypes` — the tool replies with the choices; ASK the user, then call again. If they named the type ("the summary pdf report"), pass it directly and do not ask. The report is for ONE execution: by default the most recent one, and the response states which execution was used and how many others exist — pass `runId` (execution id) to pick another. Files are saved under `outDir` (default ./qa-reports) and their paths returned. Protected parameters are masked by the report service. Requires a live connection; no agent needed.

Input parameters:

- `outDir` (string): Folder to save PDFs into. Default: ./qa-reports
- `ref` (string, required): Test case id/key (TC_123), or suite name / id.
- `reportTypes` (array): Which reports. Omit to get the choices and ASK the user. testcase: detailed | summary. suite: suite | detailed | summary.
- `runId` (string): Execution id to report on. Omit to use the most recent execution.
- `target` (string, required): Report for a test case or a suite.

### `gap_analysis` (~563 tokens)

Coverage / gap report across a scope (sprint, release, epic, feature, stories, project)

Aggregate COVERAGE report — for a chosen scope, walks each story and reports which have no tests, which have ACs not covered by any linked test case, which have no acceptance criteria at all, and (for release / projectWide scopes) which TCs are unlinked to any story. READ-ONLY: writes nothing, but emits a "Next actions" hint block for the agent to chain into tc_draft_create / tc_draft_open+update+save / story_update after asking the user.

PICK EXACTLY ONE SCOPE — the tool errors if zero or more than one is provided:
  • `sprintId`    — recommended for sprint reviews
  • `releaseId`   — release readiness across all sprints in the release
  • `epicId`      — coverage on one epic
  • `featureId`   — coverage on one feature
  • `storyIds[]`  — hand-picked batch (or a single story: the same info story_sync_testcases returns, wrapped in the gap format)
  • `projectWide: true` — every story (expensive; prefer a narrower scope when the user's question is really about a sprint / release / area)

Reuses the same AC↔step matching as `story_sync_testcases` (Jaccard, sensitivity strict / normal / loose). Automation test cases COUNT toward `tcCount` but do NOT run drift (their steps are recorded, not AC-derived — computeDrift would false-flag every AC as uncovered). Orphan-TC detection runs only for `releaseId` / `projectWide` scopes.

When the user's question is about a single story, prefer `story_sync_testcases` if they want the drift ops to apply; use this tool if they want a coverage verdict / report.

Input parameters:

- `epicId` (string): Epic numeric id or business key (EP_123).
- `featureId` (string): Feature numeric id or business key (FT_123).
- `projectWide` (boolean): Set true to scan every story in the project (bounded by scanLimit). Prefer a narrower scope when possible — projectWide fans out into many adapter calls.
- `releaseId` (string): Release id (from list_releases).
- `scanLimit` (integer): Cap on the initial listStories fetch (and, for release/projectWide, the orphan-TC scan). Default 500. Raise for a genuinely huge project.
- `sensitivity` (string): AC↔step match strictness (same as story_sync_testcases). Default `normal`.
- `sprintId` (string): Sprint id (from list_sprints).
- `storyIds` (array): One or more story ids/keys (US_123).

### `impact_analysis` (~455 tokens)

Blast-radius report from a single anchor (defect / testcase / story / sprint / release)

BLAST-RADIUS report from ONE anchor — walks the graph both ways to answer "if this is broken / unfinished, what does it affect?" READ-ONLY.

PICK EXACTLY ONE ANCHOR:
  • `defectId`   (DF_77) — walks defect → TC(s) → story → sprint → release, then sibling stories in the sprint.
  • `testCaseId` (TC_204) — walks TC → open defects on it → story → sprint → release.
  • `storyId`    (US_103) — walks story → its TCs / defects / sprint / release / sibling stories.
  • `sprintId`   — rolls up every story in the sprint: uncovered ACs, open critical / major defects, stories with no tests.
  • `releaseId`  — per-sprint table with a rolled-up release verdict.

VERDICT (traffic light, deliberately simple):
  · `AT_RISK`         — any open critical defect, OR more than 30% of ACs uncovered.
  · `NEEDS_ATTENTION` — any open major defect, OR a story in scope has zero tests.
  · `READY`           — otherwise.

Reuses `gap_analysis`'s per-story analyser to count uncovered ACs, so the AC↔step match rules (Jaccard, sensitivity) are consistent between the two tools. Writes nothing — any triage the user chooses (reassign, descope, add TC) goes through the existing write tools after they confirm.

Input parameters:

- `defectId` (string): Defect id or code (DF_77).
- `releaseId` (string): Release id (from list_releases).
- `scanLimit` (integer): Cap on the initial listStories fetch for sprint/release rollups. Default 500.
- `sensitivity` (string): AC↔step match strictness passed through to gap analysis. Default `normal`.
- `sprintId` (string): Sprint id (from list_sprints).
- `storyId` (string): Story id or business key (US_103).
- `testCaseId` (string): Test case id or code (TC_204).

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect#diagnostics

## Score history

- 2026-11-21: 68
- 2026-11-20: 68
- 2026-11-19: 67
- 2026-11-18: 41
- 2026-11-17: 66

## Common questions

### What is the simplify3x-connect MCP server?

simplify3x-connect is an MCP server listed in the public MCP registry as com.simplifyqa/simplify3x-connect. SimplifyQA test management: find, author, record, run and triage test cases. This page covers its npm package (simplify3x-connect).

### Is the simplify3x-connect MCP server safe to use?

simplify3x-connect scores 68 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the simplify3x-connect MCP server expose?

simplify3x-connect exposes 113 tools: project_info, qa_connect, qa_switch_project, qa_connection_status, qa_disconnect, and 108 more. Their descriptions and schemas cost roughly 44,141 tokens of context every time the server is loaded.

### Is the simplify3x-connect MCP server still maintained?

simplify3x-connect is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the simplify3x-connect MCP server under?

simplify3x-connect declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the simplify3x-connect MCP server?

VerifyMCP ran 16 checks on simplify3x-connect, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/simplify3x-connect
- Socket report: https://socket.dev/npm/package/simplify3x-connect
- Repository: https://github.com/Simplify3x/simplify3x-connect
- Website: https://simplifyqa.ai/
- Changelog RSS feed: https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect.json
- HTML version of this page: https://verifymcp.io/servers/com-simplifyqa-simplify3x-connect/simplify3x-connect
