common-qa-mcp 0.8.0 → 0.8.1

package/dist/tools/run.tools.d.ts

@@ -8,6 +8,10 @@ import type { ProviderAdapter } from '../adapters/types.js';
  */
 export type RunToolsDeps = {
     getAdapter: () => ProviderAdapter | null;
+    /** Current project id, used to key the in-session "reuse last run config?" prompt. When absent
+     *  or returning null, the reuse prompt is skipped entirely (tests that don't wire it get the raw
+     *  cascade). */
+    getProjectId?: () => string | null;
 };
 export declare function registerRunTools(server: McpServer, deps: RunToolsDeps): void;
 //# sourceMappingURL=run.tools.d.ts.map

package/dist/tools/run.tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.tools.d.ts","sourceRoot":"","sources":["../../src/tools/run.tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,eAAe,GAAG,IAAI,CAAC;CAC1C,CAAC;AA4IF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CA02B5E"}
+{"version":3,"file":"run.tools.d.ts","sourceRoot":"","sources":["../../src/tools/run.tools.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,eAAe,GAAG,IAAI,CAAC;IACzC;;oBAEgB;IAChB,YAAY,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACpC,CAAC;AAyKF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAq6B5E"}

package/dist/tools/run.tools.js

@@ -1,6 +1,27 @@
 import { z } from 'zod';
 import { ok, err } from '../mcpResult.js';
 const NOT_CONNECTED = 'Not connected to a product. Use qa_connect({ url, token, projectId }) first — running a test needs a live backend connection.';
+const lastRun = new Map();
+function summarizeLastRun(c) {
+    const parts = [];
+    if (c.when)
+        parts.push(`when=${c.when}`);
+    if (c.mode)
+        parts.push(`mode=${c.mode}`);
+    if (c.releaseId !== undefined)
+        parts.push(`release=${c.releaseId || '(none)'}`);
+    if (c.sprintId !== undefined)
+        parts.push(`sprint=${c.sprintId || '(none)'}`);
+    if (c.environment)
+        parts.push(`env=${c.environment}`);
+    if (c.browser)
+        parts.push(`browser=${c.browser}`);
+    if (c.agentId)
+        parts.push(`agent=${c.agentId}`);
+    if (c.cloudRunnerId)
+        parts.push(`runner=${c.cloudRunnerId}`);
+    return parts.join(', ');
+}
 function describeError(e) {
     return e instanceof Error ? e.message : String(e);
 }
@@ -266,18 +287,25 @@ export function registerRunTools(server, deps) {
     });
     server.registerTool('tc_run', {
         title: 'Run a test case (local / remote / cloud; now or scheduled)',
-        description: "Execute ONE existing test case in the connected product. ASK the user for EVERY field the " +
-            "Execute dialog asks — never assume — and in ORDER: (1) `releaseId` (from list_releases; " +
-            "pass '' if the user skips), (2) `sprintId` (from list_sprints; pass '' if the user skips), " +
-            "(3) `versionId` (from tc_get's `versions[]`; pass '' to accept the TC's current version), " +
-            '(4) `environment` (from tc_list_environments — required), (5) FOR WEB TCs: `browser` ' +
-            '(required); FOR ANDROID/IOS TCs: skip browser — `deviceType` + `deviceId` are asked in step ' +
-            "(9) instead (call `mobile_list_devices` to enumerate), (6) `mode` local/remote/cloud, (7) " +
-            "`when` immediate/schedule, (8) for a schedule the start time + recurrence + timezone, (9) " +
-            'THEN offer the eligible agent/runner and (for mobile) the device — pass the picks. The tool ' +
-            'REFUSES when any of (1)-(7) is omitted, and additionally when `deviceType`/`deviceId` are ' +
-            'omitted on a mobile TC — that is deliberate; it forces the ask instead of silently ' +
-            'defaulting. `mode` decides WHERE it runs:\n' +
+        description: "★ 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). ★\n\n" +
+            "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 + 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:\n" +
             "  • '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 machine's agent (or pass it explicitly — must be this machine's row). " +
@@ -287,54 +315,91 @@ export function registerRunTools(server, deps) {
             "remote agents are eligible; for when:'schedule' ANY remote agent works (it runs when it fires).\n" +
             "  • 'cloud' — an online cloud runner VM (ONLINE-only whether now or scheduled). Pass `cloudRunnerId` " +
             'from cloud_runners; for a schedule omit it to let the backend auto-pick a live VM at fire time.\n' +
-            'IF THE USER HAS NOT SAID local, remote, or cloud, ASK — this tool refuses when `mode` is omitted. For cloud, ' +
-            'if no runner is online it reports that there are no active cloud runners (nothing is run).\n' +
-            '`when` decides WHEN it runs (this tool REFUSES when `when` is omitted — ASK the user):\n' +
-            "  • 'immediate' — dispatch now; returns the run id — poll run_status for the result.\n" +
-            "  • 'schedule' — create a schedule instead (requires `scheduledFor`); ASK the start time, recurrence, " +
-            'end date and timezone BEFORE offering an agent. Returns the schedule id.\n' +
+            'For cloud, if no runner is online it reports that there are no active cloud runners (nothing is run).\n' +
             'NOTE: MANUAL test cases cannot be run or scheduled by an agent — the backend rejects them.',
         inputSchema: {
             tcId: z.string().describe('The test case id (or business key) to run.'),
-            mode: z.enum(['local', 'remote', 'cloud']).optional().describe("Where to run. REQUIRED — ASK the user if unstated (the tool refuses when omitted)."),
-            agentId: z.string().optional().describe("For local: a specific agent credential_id from `local_agents` (must be THIS machine's row; omit to auto-pick). For remote: REQUIRED — a credential_id from `remote_agents` (a teammate's row). when:'immediate' → the picked agent must be ONLINE; when:'schedule' → offline agents are OK (they run when they fire) and `agentId` is REQUIRED for both local and remote."),
-            releaseId: z.string().optional().describe('Tag the run with a RELEASE (from list_releases). Optional in the UI; omit to leave untagged.'),
-            sprintId: z.string().optional().describe('Tag the run with a SPRINT (from list_sprints). Optional in the UI; omit to leave untagged.'),
-            versionId: z.string().optional().describe("Override the TC's currently-selected VERSION for this run (an id from the TC's `versions[]`). Omit to run the current version — that's what the UI's Version chip defaults to."),
-            environment: z.string().optional().describe('Environment key (from tc_list_environments). ASK the user before running — the UI marks this required.'),
-            browser: z.string().optional().describe("Browser, default 'chromium' (bundled + isolated). Others: 'chrome'/'msedge' (installed channel), 'firefox', 'webkit'. NOTE: a schedule accepts only chromium/msedge/firefox/webkit."),
+            reuseConfig: z.boolean().optional().describe("Set only when the tool refused asking about REUSE. true = merge the previous run's mode/release/sprint/env/browser/agent/runner into any unset field; false = ignore prior config and walk the full cascade. Omit on a first run."),
+            when: z.enum(['immediate', 'schedule']).optional().describe("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)."),
+            mode: z.enum(['local', 'remote', 'cloud']).optional().describe("STEP 2 — where to run. REQUIRED, ASK the user if unstated."),
+            releaseId: z.string().optional().describe("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."),
+            sprintId: z.string().optional().describe("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."),
+            versionId: z.string().optional().describe("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."),
+            environment: z.string().optional().describe('STEP 6 — environment key (from tc_list_environments). ASK the user; the UI marks this required.'),
+            browser: z.string().optional().describe("STEP 7 (WEB TCs) — browser, default 'chromium' (bundled + isolated). Others: 'chrome'/'msedge' (installed channel), 'firefox', 'webkit'. NOTE: a schedule accepts only chromium/msedge/firefox/webkit."),
+            deviceId: z.string().optional().describe("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`."),
+            deviceType: z.enum(['real_device', 'emulator', 'simulator', 'cloud_device', 'cloud_emulator', 'cloud_simulator']).optional().describe("STEP 7 (ANDROID/IOS TCs) — the KIND of device the picked `deviceId` is (read off the matching row from `mobile_list_devices`)."),
+            cloudDeviceType: z.enum(['lambda_test', 'browser_stack', 'sauce_labs', 'simplify_qa_device_form']).optional().describe("REQUIRED when `deviceType` is cloud_* — which cloud farm the device came from (read off the matching row's `cloudDeviceType`)."),
+            osVersion: z.string().optional().describe("Optional OS version to stamp on the wire platform object for ANDROID/IOS — read off the matching row from `mobile_list_devices`."),
+            agentId: z.string().optional().describe("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 agent must be ONLINE; when:'schedule' → offline OK and `agentId` is REQUIRED for both local and remote."),
+            cloudRunnerId: z.string().optional().describe("STEP 9 (cloud) — a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time."),
             headless: z.boolean().optional().describe('Headless. Defaults: cloud=true, local=false. (Immediate runs only.)'),
-            cloudRunnerId: z.string().optional().describe("For cloud: a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time."),
-            deviceId: z.string().optional().describe("REQUIRED for ANDROID/IOS test cases — the target device id. LOCAL: adb serial or emulator name. CLOUD: the marketplace device name. Enumerate with `mobile_list_devices`."),
-            deviceType: z.enum(['real_device', 'emulator', 'simulator', 'cloud_device', 'cloud_emulator', 'cloud_simulator']).optional().describe("REQUIRED for ANDROID/IOS test cases — the KIND of device the picked `deviceId` is (read off the matching row from `mobile_list_devices`). Drives the wire execution platform's `type` field."),
-            cloudDeviceType: z.enum(['lambda_test', 'browser_stack', 'sauce_labs', 'simplify_qa_device_form']).optional().describe("REQUIRED when `deviceType` is cloud_* — which cloud farm the device came from (read off the matching row's `cloudDeviceType` from `mobile_list_devices`). Note SIMPLIFY_QA_DEVICE_FORM's legacy 'FORM' spelling — mirrors the SQA wire schema exactly."),
-            osVersion: z.string().optional().describe("Optional OS version to stamp on the wire platform object for ANDROID/IOS — read off the matching row from `mobile_list_devices`. Ignored for non-mobile tcTypes."),
-            when: z.enum(['immediate', 'schedule']).optional().describe("When to run — REQUIRED, ASK the user if unstated (the tool refuses when omitted). 'immediate' dispatches now; 'schedule' creates a schedule (needs scheduledFor)."),
-            scheduledFor: z.string().optional().describe("REQUIRED for when:'schedule' — ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z')."),
+            scheduledFor: z.string().optional().describe("STEP 8 — REQUIRED for when:'schedule'; ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z')."),
             scheduleType: z.enum(['once', 'hourly', 'daily', 'weekdays', 'weekly', 'monthly']).optional().describe("Recurrence for a schedule. Default 'once'. hourly/daily/weekdays require an endDate."),
             endDate: z.string().optional().describe('For a recurring schedule — ISO end date (required for hourly/daily/weekdays).'),
             timezone: z.string().optional().describe("IANA timezone for a schedule (e.g. 'Asia/Kolkata'). Default 'UTC'."),
         },
         annotations: { readOnlyHint: false },
-    }, async ({ tcId, mode, agentId, environment, browser, headless, cloudRunnerId, deviceId, deviceType, cloudDeviceType, osVersion, when, scheduledFor, scheduleType, endDate, timezone, releaseId, sprintId, versionId }) => {
+    }, async ({ tcId, reuseConfig, when, mode, agentId, environment, browser, headless, cloudRunnerId, deviceId, deviceType, cloudDeviceType, osVersion, scheduledFor, scheduleType, endDate, timezone, releaseId, sprintId, versionId }) => {
         const adapter = deps.getAdapter();
         if (!adapter)
             return err(NOT_CONNECTED);
-        // Mirror the Execute-dialog required-field enforcement — ASK the user for every field the UI
-        // asks. Release/sprint/version are optional in the UI; pass '' after asking to accept the
-        // default (untagged / TC's current version). Environment and browser have red asterisks.
+        // STEP 0 — reuse-last-config prompt. Fires only when the caller wired getProjectId AND there
+        // is a remembered config for that project AND the caller has not answered yet (undefined).
+        // Merging when `reuseConfig: true` fills only fields left unset by this call — the user can
+        // still override any single field explicitly. TC-specific fields (versionId, deviceId,
+        // schedule cadence) are never remembered — they belong to the run, not the environment.
+        const projectId = deps.getProjectId?.() ?? null;
+        const remembered = projectId ? lastRun.get(projectId) : undefined;
+        if (remembered && reuseConfig === undefined) {
+            return err(`Previous run in this project used: ${summarizeLastRun(remembered)}. ` +
+                'ASK the user whether to reuse it — call tc_run again with `reuseConfig: true` to merge ' +
+                'those defaults, or `reuseConfig: false` to start fresh and be asked each field.');
+        }
+        if (reuseConfig === true && remembered) {
+            if (when === undefined)
+                when = remembered.when;
+            if (mode === undefined)
+                mode = remembered.mode;
+            if (releaseId === undefined)
+                releaseId = remembered.releaseId;
+            if (sprintId === undefined)
+                sprintId = remembered.sprintId;
+            if (environment === undefined)
+                environment = remembered.environment;
+            if (browser === undefined)
+                browser = remembered.browser;
+            if (agentId === undefined)
+                agentId = remembered.agentId;
+            if (cloudRunnerId === undefined)
+                cloudRunnerId = remembered.cloudRunnerId;
+        }
+        // STEP 1 — when. Decides schedule vs immediate; gates the schedule fields and the agent
+        // online-check downstream, so ask before anything else.
+        if (!when) {
+            return err("Specify WHEN to run: call tc_run again with when: 'immediate' (run now) or when: 'schedule' " +
+                '(create a schedule). If the user has not said, ask them first — never assume.');
+        }
+        // STEP 2 — mode. Decides the agent/runner pool and constrains the browser set for a schedule.
+        if (!mode) {
+            return err("Specify where to run: call tc_run again with mode: 'local', 'remote', or 'cloud'. " +
+                "If the user has not said which, ASK them first — local runs on THIS machine's agent, " +
+                "remote runs on a teammate's registered agent, cloud runs on an online cloud runner VM.");
+        }
+        // STEP 3 — release. Optional in the UI; the tool asks anyway (pass '' to skip).
         if (releaseId === undefined) {
             return err("ASK the user which RELEASE this run belongs to (from list_releases), then call tc_run " +
                 "again with releaseId. If the user wants no release, pass releaseId: '' (empty string).");
         }
-        if (sprintId === undefined) {
-            return err("ASK the user which SPRINT this run belongs to (from list_sprints), then call tc_run " +
-                "again with sprintId. If the user wants no sprint, pass sprintId: '' (empty string).");
+        // STEP 4 — sprint. Only asked when a release was picked; when release is skipped, sprint is
+        // skipped entirely (sprints scope to a release in the UI).
+        if (releaseId !== '' && sprintId === undefined) {
+            return err("ASK the user which SPRINT this run belongs to (from list_sprints, filtered by releaseId), " +
+                "then call tc_run again with sprintId. If the user wants no sprint, pass sprintId: '' (empty string).");
         }
-        // Pre-flight the TC once — needed both to inline the version list (below) and to know the
-        // tcType (WEB vs ANDROID/IOS/…) so the refuse cascade asks the right platform-specific
-        // fields: browser for WEB, deviceType + deviceId for mobile. Mirrors tc_get's refusal at
-        // discovery.tools.ts:226; without this the model guesses a version NAME and the backend 500s.
+        if (releaseId === '')
+            sprintId = '';
+        // STEP 5 — version. Needs the TC's tcType and version list, so pre-fetch once here.
         let preview;
         try {
             preview = await adapter.getTestCase(tcId);
@@ -357,30 +422,19 @@ export function registerRunTools(server, deps) {
             }
             versionId = '';
         }
+        // STEP 6 — environment.
         if (!environment) {
             return err('ASK the user which ENVIRONMENT to run against (from tc_list_environments), then call ' +
                 'tc_run again with environment set to the chosen env key. Required — the UI marks this ' +
                 'field with a red asterisk.');
         }
-        // Browser is a WEB-only field — the SQA Execute dialog doesn't render it for mobile TCs
-        // (they show a device picker instead). Skip the refuse for ANDROID/IOS; the adapter's
-        // buildRunPlatform will ignore any browser passed alongside a mobile deviceId.
+        // STEP 7 (web only) — browser. Mobile branch handled after mode-dependent cloud/agent
+        // resolution, since the device roster is filtered by where it will run.
         if (!isMobile && !browser) {
             return err("ASK the user which BROWSER to run in (chromium / chrome / msedge / firefox / webkit), " +
                 'then call tc_run again with browser set. Required — the UI marks this field with a ' +
                 'red asterisk.');
         }
-        if (!mode) {
-            return err("Specify where to run: call tc_run again with mode: 'local', 'remote', or 'cloud'. " +
-                "If the user has not said which, ASK them first — local runs on THIS machine's agent, " +
-                "remote runs on a teammate's registered agent, cloud runs on an online cloud runner VM.");
-        }
-        // Never assume now-vs-scheduled — it decides which agents are eligible (online-only for now,
-        // online+offline for a local schedule) and, for a schedule, the start time asked next.
-        if (!when) {
-            return err("Specify WHEN to run: call tc_run again with when: 'immediate' (run now) or when: 'schedule' " +
-                '(create a schedule). If the user has not said, ask them first — never assume.');
-        }
         let resolvedRunner;
         if (mode === 'cloud') {
             if (!adapter.listCloudRunners)
@@ -484,6 +538,8 @@ export function registerRunTools(server, deps) {
                 const where = mode === 'cloud'
                     ? (pinnedRunner ? `cloud runner **${pinnedRunner.name}**` : 'cloud (auto-pick a live VM at run time)')
                     : `agent \`${agentId}\``;
+                if (projectId)
+                    lastRun.set(projectId, { when, mode, releaseId, sprintId, environment, browser, agentId, cloudRunnerId });
                 return ok(`Scheduled ${tcId} (${scheduleType ?? 'once'}, ${mode}) for ${scheduledFor}${next} → ${where}. Schedule id \`${sched.id}\`.`, { schedule: sched, mode, when: 'schedule', ...(pinnedRunner ? { runner: pinnedRunner } : {}) });
             }
             catch (e) {
@@ -512,6 +568,8 @@ export function registerRunTools(server, deps) {
                 : mode === 'remote'
                     ? `on remote agent \`${agentId}\``
                     : `locally${agentId ? ` on agent \`${agentId}\`` : ' on your online agent'}`;
+            if (projectId)
+                lastRun.set(projectId, { when, mode, releaseId, sprintId, environment, browser, agentId, cloudRunnerId: resolvedRunner?.id ?? cloudRunnerId });
             return ok(`Started ${tcId} ${where}. Run id \`${run.runId}\` — poll run_status({ runId: "${run.runId}" }) for progress.`, { run, mode, ...(resolvedRunner ? { runner: resolvedRunner } : {}) });
         }
         catch (e) {
@@ -520,15 +578,24 @@ export function registerRunTools(server, deps) {
     });
     server.registerTool('suite_run', {
         title: 'Run a test suite (local / remote / cloud; now or scheduled)',
-        description: '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 — and in ORDER ' +
-            '(mirrors the product UI, `_parentComponent==="SU"`): (1) `releaseId` (from list_releases — the UI ' +
-            'marks it required with `*` for a suite), (2) `sprintId` (from list_sprints — also `*` for a suite), ' +
-            '(3) `environment` (from tc_list_environments — `*`), (4) `mode` local/remote/cloud, (5) `when` immediate/schedule, ' +
-            '(6) for a schedule the start time + recurrence + timezone, (7) THEN offer the eligible agent/runner. ' +
-            'The tool REFUSES when any of (1)–(5) is omitted — that is deliberate; it forces the ask instead of ' +
-            'silently defaulting. 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). " +
+        description: "★ ORDER OF QUESTIONS (STRICT — applies whether you ask one at a time OR bundle several into a " +
+            "single message): when → mode → 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. ★\n\n" +
+            '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/env/agent, " +
+            "false=start fresh); (1) `when` immediate/schedule, (2) `mode` local/remote/cloud, (3) " +
+            "`releaseId` (from list_releases; pass '' to skip), (4) `sprintId` (from list_sprints; skipped " +
+            "entirely when releaseId=''), (5) `environment` (from tc_list_environments), (6) for a schedule " +
+            "the start time + recurrence + timezone, (7) THEN offer the eligible agent/runner. IF YOU " +
+            "BATCH SEVERAL REFUSED FIELDS INTO ONE AskUserQuestion, ORDER the questions EXACTLY as above " +
+            "(when → mode → 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). " +
             '`mode` decides WHERE it runs:\n' +
             "  • 'local' — THIS machine's desktop agent, always serial. Call `local_agents` (0 or 1 row). For " +
             "when:'immediate' the tool probes :4040 and refuses if the desktop agent is down. Omit `agentId` to " +
@@ -538,66 +605,90 @@ export function registerRunTools(server, deps) {
             "  • 'cloud' — online cloud runner VM(s) (ONLINE-only whether now or scheduled). Pass `cloudRunnerId` " +
             'from cloud_runners; for a schedule omit it to auto-pick a live VM at fire time.\n' +
             'For cloud, if no runner is online it reports that there are no active cloud runners (nothing is run).\n' +
-            '`when` decides WHEN it runs:\n' +
-            "  • 'immediate' — dispatch now; returns the suite-run id — poll run_status for progress " +
-            '(per-test-case results under `children`) and run_stop to cancel.\n' +
-            "  • 'schedule' — create a schedule instead (requires `scheduledFor`); ASK the start time, recurrence, " +
-            'end date and timezone BEFORE offering an agent. Returns the schedule id.\n' +
-            'NOTE: a suite of only MANUAL test cases cannot be run or scheduled by an agent — the backend rejects it.',
+            'NOTE: manual suites go through the same dispatch — the backend stores them as an execution (no agent picks them up until steps are marked from the UI).',
         inputSchema: {
             suiteId: z.string().describe('The suite id to run (from suite_list / suite_get).'),
-            releaseId: z.string().optional().describe('REQUIRED for a suite (UI marks it `*` for _parentComponent==="SU"). A release id from list_releases. Ask the user.'),
-            sprintId: z.string().optional().describe('REQUIRED for a suite (UI marks it `*` for _parentComponent==="SU"). A sprint id from list_sprints (scoped to the picked release). Ask the user.'),
-            mode: z.enum(['local', 'remote', 'cloud']).optional().describe('Where to run. REQUIRED — ASK the user if unstated (the tool refuses when omitted).'),
-            agentId: z.string().optional().describe("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 ONLINE; when:'schedule' → offline OK, agentId REQUIRED for both local and remote."),
-            environment: z.string().optional().describe('Environment key (from tc_list_environments). REQUIRED — the UI marks this with a red asterisk for a suite.'),
+            reuseConfig: z.boolean().optional().describe("Set only when the tool refused asking about REUSE. true = merge the previous run's mode/release/sprint/env/browser/agent/runner into any unset field; false = ignore prior config. Omit on a first run."),
+            when: z.enum(['immediate', 'schedule']).optional().describe("STEP 1 — when to run. REQUIRED, ASK the user if unstated."),
+            mode: z.enum(['local', 'remote', 'cloud']).optional().describe('STEP 2 — where to run. REQUIRED, ASK the user if unstated.'),
+            releaseId: z.string().optional().describe("STEP 3 — release from list_releases. ASK the user; pass '' to skip (no release / no sprint asked)."),
+            sprintId: z.string().optional().describe("STEP 4 — sprint from list_sprints (scoped to release). Only asked when releaseId is non-empty; skipped when releaseId=''. Pass '' to skip."),
+            environment: z.string().optional().describe('STEP 5 — environment key (from tc_list_environments). ASK the user; the UI marks this required for a suite.'),
             browser: z.string().optional().describe("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), 'chrome'/'msedge', 'firefox', 'webkit'. NOTE: a schedule accepts only chromium/msedge/firefox/webkit."),
             headless: z.boolean().optional().describe('Headless. Defaults: cloud=true, local=false. (Immediate runs only.)'),
-            cloudRunnerId: z.string().optional().describe("For cloud: a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time."),
-            strategy: z.enum(['serial', 'batch', 'dynamic']).optional().describe('Cloud dispatch order across the suite (immediate runs). Default serial; local is always serial.'),
-            maxConcurrent: z.number().int().positive().optional().describe('Cloud batch/dynamic only — max test cases running at once (immediate runs).'),
-            terminateOnFailure: z.boolean().optional().describe('Stop dispatching remaining test cases after the first failure (immediate runs).'),
-            when: z.enum(['immediate', 'schedule']).optional().describe("When to run — REQUIRED, ASK the user if unstated (the tool refuses when omitted). 'immediate' dispatches now; 'schedule' creates a schedule (needs scheduledFor)."),
-            scheduledFor: z.string().optional().describe("REQUIRED for when:'schedule' — ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z')."),
+            agentId: z.string().optional().describe("STEP 7 — 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 ONLINE; when:'schedule' → offline OK, agentId REQUIRED for both local and remote."),
+            cloudRunnerId: z.string().optional().describe("STEP 7 (cloud) — a specific ONLINE runner id (from cloud_runners). For when:'schedule' omit to auto-pick a live VM at fire time."),
+            strategy: z.enum(['serial', 'parallel']).optional().describe("Dispatch order across the suite's test cases. Wire only accepts SERIAL / PARALLEL (backend validator). Default 'serial'; LOCAL is always serial regardless."),
+            maxConcurrent: z.number().int().positive().optional().describe('Cloud parallel only — maps to globalConfiguration.MAXIMUM_CONTAINER_COUNT on the wire.'),
+            terminateOnFailure: z.boolean().optional().describe('Stop dispatching remaining test cases after the first failure. Maps to globalConfiguration.TERMINATE_ON_FAIL on the wire.'),
+            scheduledFor: z.string().optional().describe("STEP 6 — REQUIRED for when:'schedule'; ISO datetime of the first/only run (e.g. '2026-08-20T09:00:00Z')."),
             scheduleType: z.enum(['once', 'hourly', 'daily', 'weekdays', 'weekly', 'monthly']).optional().describe("Recurrence for a schedule. Default 'once'. hourly/daily/weekdays require an endDate."),
             endDate: z.string().optional().describe('For a recurring schedule — ISO end date (required for hourly/daily/weekdays).'),
             timezone: z.string().optional().describe("IANA timezone for a schedule (e.g. 'Asia/Kolkata'). Default 'UTC'."),
         },
         annotations: { readOnlyHint: false },
-    }, async ({ suiteId, releaseId, sprintId, mode, agentId, environment, browser, headless, cloudRunnerId, strategy, maxConcurrent, terminateOnFailure, when, scheduledFor, scheduleType, endDate, timezone }) => {
+    }, async ({ suiteId, reuseConfig, releaseId, sprintId, mode, agentId, environment, browser, headless, cloudRunnerId, strategy, maxConcurrent, terminateOnFailure, when, scheduledFor, scheduleType, endDate, timezone }) => {
         const adapter = deps.getAdapter();
         if (!adapter)
             return err(NOT_CONNECTED);
-        // Mirror the Execute-suite dialog required-field enforcement (_parentComponent==='SU' branch of
-        // execution-popup-modal.component.html) — release, sprint, environment all carry a red `*` for
-        // a suite. UNLIKE tc_run, empty-string is NOT accepted: the UI blocks form submit until each is
-        // picked. `versionId` and `browser` are TC-level in a suite (each row has its own) so we
-        // don't ask for them.
-        if (!releaseId) {
+        // STEP 0 — reuse-last-config prompt. Same shape as tc_run: fires only when the caller wired
+        // getProjectId AND there is a remembered config AND the user hasn't answered yet. Merges the
+        // environment-level fields (mode/release/sprint/env/browser/agent/runner) into any left unset.
+        const projectId = deps.getProjectId?.() ?? null;
+        const remembered = projectId ? lastRun.get(projectId) : undefined;
+        if (remembered && reuseConfig === undefined) {
+            return err(`Previous run in this project used: ${summarizeLastRun(remembered)}. ` +
+                'ASK the user whether to reuse it — call suite_run again with `reuseConfig: true` to merge ' +
+                'those defaults, or `reuseConfig: false` to start fresh.');
+        }
+        if (reuseConfig === true && remembered) {
+            if (when === undefined)
+                when = remembered.when;
+            if (mode === undefined)
+                mode = remembered.mode;
+            if (releaseId === undefined)
+                releaseId = remembered.releaseId;
+            if (sprintId === undefined)
+                sprintId = remembered.sprintId;
+            if (environment === undefined)
+                environment = remembered.environment;
+            if (browser === undefined)
+                browser = remembered.browser;
+            if (agentId === undefined)
+                agentId = remembered.agentId;
+            if (cloudRunnerId === undefined)
+                cloudRunnerId = remembered.cloudRunnerId;
+        }
+        // STEP 1 — when.
+        if (!when) {
+            return err("Specify WHEN to run: call suite_run again with when: 'immediate' (run now) or when: 'schedule' " +
+                '(create a schedule). If the user has not said, ask them first — never assume.');
+        }
+        // STEP 2 — mode.
+        if (!mode) {
+            return err("Specify where to run: call suite_run again with mode: 'local', 'remote', or 'cloud'. " +
+                "If the user has not said which, ASK them first — local runs on THIS machine's agent, " +
+                "remote runs on a teammate's registered agent, cloud runs on online cloud runner VM(s).");
+        }
+        // STEP 3 — release. Unified with tc_run: pass '' to skip (matches the UI's optional field).
+        if (releaseId === undefined) {
             return err("ASK the user which RELEASE this suite run belongs to (from list_releases), then call " +
-                'suite_run again with releaseId. Required for a suite — the UI marks it with a red asterisk.');
+                "suite_run again with releaseId. If the user wants no release, pass releaseId: '' (empty string).");
         }
-        if (!sprintId) {
+        // STEP 4 — sprint. Only asked when release is non-empty.
+        if (releaseId !== '' && sprintId === undefined) {
             return err("ASK the user which SPRINT this suite run belongs to (from list_sprints, filtered by " +
-                'releaseId), then call suite_run again with sprintId. Required for a suite — the UI marks it ' +
-                'with a red asterisk.');
+                "releaseId), then call suite_run again with sprintId. If the user wants no sprint, pass " +
+                "sprintId: '' (empty string).");
         }
+        if (releaseId === '')
+            sprintId = '';
+        // STEP 5 — environment.
         if (!environment) {
             return err('ASK the user which ENVIRONMENT to run against (from tc_list_environments), then call ' +
                 'suite_run again with environment set to the chosen env key. Required — the UI marks this ' +
                 'field with a red asterisk for a suite.');
         }
-        if (!mode) {
-            return err("Specify where to run: call suite_run again with mode: 'local', 'remote', or 'cloud'. " +
-                "If the user has not said which, ASK them first — local runs on THIS machine's agent, " +
-                "remote runs on a teammate's registered agent, cloud runs on online cloud runner VM(s).");
-        }
-        // Never assume now-vs-scheduled — it decides which agents are eligible (online-only for now,
-        // online+offline for a local schedule) and, for a schedule, the start time asked next.
-        if (!when) {
-            return err("Specify WHEN to run: call suite_run again with when: 'immediate' (run now) or when: 'schedule' " +
-                '(create a schedule). If the user has not said, ask them first — never assume.');
-        }
         let resolvedRunner;
         if (mode === 'cloud') {
             if (!adapter.listCloudRunners)
@@ -671,6 +762,8 @@ export function registerRunTools(server, deps) {
                 const where = mode === 'cloud'
                     ? (pinnedRunner ? `cloud runner **${pinnedRunner.name}**` : 'cloud (auto-pick a live VM at run time)')
                     : `agent \`${agentId}\``;
+                if (projectId)
+                    lastRun.set(projectId, { when, mode, releaseId, sprintId, environment, browser, agentId, cloudRunnerId });
                 return ok(`Scheduled suite ${suiteId} (${scheduleType ?? 'once'}, ${mode}) for ${scheduledFor}${next} → ${where}. Schedule id \`${sched.id}\`.`, { schedule: sched, mode, when: 'schedule', ...(pinnedRunner ? { runner: pinnedRunner } : {}) });
             }
             catch (e) {
@@ -697,6 +790,8 @@ export function registerRunTools(server, deps) {
                 : mode === 'remote'
                     ? `on remote agent \`${agentId}\``
                     : `locally${agentId ? ` on agent \`${agentId}\`` : ' on your online agent'}`;
+            if (projectId)
+                lastRun.set(projectId, { when, mode, releaseId, sprintId, environment, browser, agentId, cloudRunnerId: resolvedRunner?.id ?? cloudRunnerId });
             return ok(`Started suite ${suiteId} ${where}. Run id \`${run.runId}\` — poll run_status({ runId: "${run.runId}" }) for progress.`, { run, mode, ...(resolvedRunner ? { runner: resolvedRunner } : {}) });
         }
         catch (e) {