common-qa-mcp 0.8.0 → 0.9.0

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);
 }
@@ -119,14 +140,87 @@ function statusText(s) {
             (total > 0 ? '\n\nTo see WHY a specific one passed/failed, call run_status again with the same runId ' +
                 'plus `tcId` set to one of the ids above.' : '')
         : '';
+    // First 5 non-blank lines of the raw error string — the previous single-line slice usually
+    // showed a "[ERROR] session …" log prefix instead of the actual exception. Enough context for
+    // the LLM to name the failure ("NoSuchElement on #foo") without dumping a full stack.
+    const errBlock = (raw) => {
+        if (!raw)
+            return '';
+        const lines = raw.split('\n').map((l) => l.trim()).filter((l) => l.length > 0).slice(0, 5);
+        return lines.map((l) => `  ${l}`).join('\n');
+    };
+    const stepIcon = (st) => st === 'passed' ? '✅' : st === 'failed' ? '❌' : st === 'skipped' ? '⏭️' : '•';
     const steps = s.stepResults?.length
         ? '\n\n' + s.stepResults.map((st) => {
-            const stIcon = st.status === 'passed' ? '✅' : st.status === 'failed' ? '❌' : '•';
-            const errLine = st.error ? `\n  ${st.error.split('\n')[0]}` : '';
-            return `${stIcon} step ${st.n}: ${st.description} (${st.status})${errLine}`;
+            const desc = st.description?.trim() || '(no description)';
+            const err = errBlock(st.error);
+            return `${stepIcon(st.status)} step ${st.n}: ${desc} (${st.status})${err ? '\n' + err : ''}`;
+        }).join('\n')
+        : '';
+    // Failed-step summary: hoist FAILED rows to the top so the LLM sees "which step, why" without
+    // scanning the full list. Only fires when the run itself is failed AND at least one step row is
+    // failed (a run can be marked FAILED before any step logs, in which case the reportUrl is the
+    // only lead). Multi-step failures are all listed — cascading failures often clarify the root.
+    const failedSteps = (s.stepResults ?? []).filter((st) => st.status === 'failed');
+    const failedSummary = s.state === 'failed' && failedSteps.length
+        ? '\n\n**Failed at:**\n' + failedSteps.map((st) => {
+            const desc = st.description?.trim() || '(no description)';
+            const err = errBlock(st.error);
+            return `- step ${st.n}: ${desc}${err ? '\n' + err : ''}`;
         }).join('\n')
         : '';
-    return `Run ${s.runId} · **${s.state}**${prog}${when}${tally}${link}${kids}${steps}`;
+    return `Run ${s.runId} · **${s.state}**${prog}${when}${tally}${link}${failedSummary}${kids}${steps}`;
+}
+/** Compact per-run bullet list for `run_history`. Matches the icon vocabulary `statusText` uses so
+ *  the two outputs feel like one surface. Duration only shows when both timestamps are present
+ *  (running/queued rows will read as `-> (running)` without a `(53s)` suffix). */
+function renderRunHistory(type, entityId, runs) {
+    const stateIcon = (st) => st === 'passed' ? '✅'
+        : st === 'failed' ? '❌'
+            : st === 'running' ? '⏳'
+                : st === 'skipped' ? '⏭️'
+                    : st === 'notExecuted' ? '➖'
+                        : st === 'stopped' ? '⏹️'
+                            : st === 'error' ? '⚠️'
+                                : '•';
+    const durationOf = (r) => {
+        if (!r.startedAt || !r.endedAt)
+            return '';
+        const start = Date.parse(r.startedAt);
+        const end = Date.parse(r.endedAt);
+        if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+            return '';
+        const secs = Math.round((end - start) / 1000);
+        if (secs < 60)
+            return ` (${secs}s)`;
+        const m = Math.floor(secs / 60);
+        const s = secs % 60;
+        return ` (${m}m ${s.toString().padStart(2, '0')}s)`;
+    };
+    const when = (r) => {
+        if (r.startedAt && r.endedAt)
+            return ` · ${r.startedAt} → ${r.endedAt}${durationOf(r)}`;
+        if (r.startedAt)
+            return ` · started ${r.startedAt}`;
+        return '';
+    };
+    const tally = (r) => {
+        if (type !== 'SUITE' || r.totalTestCases === undefined)
+            return '';
+        const parts = [`${r.passed ?? 0}✅`];
+        parts.push(`${r.failed ?? 0}❌`);
+        parts.push(`${r.skipped ?? 0}⏭`);
+        if ((r.notExecuted ?? 0) > 0)
+            parts.push(`${r.notExecuted}➖`);
+        return ` · ${parts.join('/')} of ${r.totalTestCases}`;
+    };
+    const label = type === 'SUITE' ? 'suite' : 'test case';
+    const header = `Recent executions of ${label} ${entityId} (${runs.length} shown):\n`;
+    const lines = runs.map((r) => `- ${stateIcon(r.state)} ${r.runId} · ${r.state}${tally(r)}${when(r)}`);
+    const hint = type === 'SUITE'
+        ? '\n\nCall run_status({ runId: "<id>" }) for the per-test-case rollup, then again with tcId for a child\'s steps.'
+        : '\n\nCall run_status({ runId: "<id>" }) for step-level detail on any one.';
+    return header + '\n' + lines.join('\n') + hint;
 }
 export function registerRunTools(server, deps) {
     server.registerTool('cloud_runners', {
@@ -266,18 +360,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 +388,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 +495,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 +611,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 +641,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 +651,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,65 +678,89 @@ 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) {
-            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.');
+        // 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 (!sprintId) {
-            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.');
+        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;
         }
-        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.');
+        // 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).");
         }
-        // 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.');
+        // 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. If the user wants no release, pass releaseId: '' (empty string).");
+        }
+        // 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. 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.');
         }
         let resolvedRunner;
         if (mode === 'cloud') {
@@ -671,6 +835,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 +863,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) {
@@ -768,18 +936,96 @@ export function registerRunTools(server, deps) {
             return err(describeError(e));
         }
     });
+    server.registerTool('run_history', {
+        title: 'Recent execution history for a suite or test case',
+        description: '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.',
+        inputSchema: {
+            suiteId: z.string().optional().describe('A suite id (from suite_list) — returns the suite\'s recent executions.'),
+            tcId: z.string().optional().describe('A test case id — returns the TC\'s recent STANDALONE executions.'),
+            limit: z.number().int().min(1).max(20).optional().describe('How many recent runs to return (default 5, max 20).'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ suiteId, tcId, limit }) => {
+        const adapter = deps.getAdapter();
+        if (!adapter)
+            return err(NOT_CONNECTED);
+        if ((suiteId && tcId) || (!suiteId && !tcId)) {
+            return err('Pass exactly one of `suiteId` or `tcId`.');
+        }
+        if (!adapter.listRecentRuns) {
+            return err('This product does not support run-history lookup.');
+        }
+        const type = suiteId ? 'SUITE' : 'TC';
+        const entityId = (suiteId ?? tcId);
+        const n = Math.min(Math.max(limit ?? 5, 1), 20);
+        try {
+            const runs = await adapter.listRecentRuns(type, entityId, n);
+            if (!runs.length) {
+                const label = type === 'SUITE' ? 'suite' : 'test case';
+                return ok(`No executions found for ${label} ${entityId}.`, { runs: [] });
+            }
+            const text = renderRunHistory(type, entityId, runs);
+            return ok(text, { runs });
+        }
+        catch (e) {
+            return err(describeError(e));
+        }
+    });
     server.registerTool('run_stop', {
         title: 'Stop a run',
-        description: 'Signal a running execution to stop. Requires a live connection.',
-        inputSchema: { runId: z.string().describe('The run id to stop.') },
+        description: '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.',
+        inputSchema: {
+            runId: z.string().optional().describe('The run id (from tc_run / suite_run).'),
+            suiteId: z.string().optional().describe("A suite id (from suite_list) — stops the suite's latest execution."),
+            tcId: z.string().optional().describe("A test case id — stops the TC's latest STANDALONE execution."),
+        },
         annotations: { readOnlyHint: false },
-    }, async ({ runId }) => {
+    }, async ({ runId, suiteId, tcId }) => {
         const adapter = deps.getAdapter();
         if (!adapter)
             return err(NOT_CONNECTED);
+        if ([runId, suiteId, tcId].filter((v) => v !== undefined && v !== '').length !== 1) {
+            return err('Pass exactly one of `runId`, `suiteId`, or `tcId`.');
+        }
         try {
-            await adapter.stopRun(runId);
-            return ok(`Requested stop for run ${runId}.`);
+            let effectiveRunId = runId;
+            if (suiteId) {
+                if (!adapter.getLatestSuiteRun)
+                    return err('This product does not support latest-suite-run lookup — pass `runId` instead.');
+                const latest = await adapter.getLatestSuiteRun(suiteId);
+                if (!latest)
+                    return err(`Suite ${suiteId} has no executions to stop.`);
+                effectiveRunId = latest;
+            }
+            else if (tcId) {
+                if (!adapter.getLatestTestcaseRun)
+                    return err('This product does not support latest-testcase-run lookup — pass `runId` instead.');
+                const latest = await adapter.getLatestTestcaseRun(tcId);
+                if (!latest)
+                    return err(`Test case ${tcId} has no executions to stop.`);
+                effectiveRunId = latest;
+            }
+            await adapter.stopRun(effectiveRunId);
+            // Confirm — the backend accepts the stop async, so getRun is the source of truth. Poll a few
+            // times so the reply reports the actual state instead of lying "requested" and moving on.
+            // ponytail: fixed 3×1.5s poll, upgrade to configurable/backoff if teams hit slow stop paths.
+            const TERMINAL = new Set(['stopped', 'passed', 'failed', 'error', 'skipped', 'notExecuted']);
+            for (let i = 0; i < 3; i++) {
+                await new Promise((r) => setTimeout(r, 1500));
+                const s = await adapter.getRun(effectiveRunId);
+                if (TERMINAL.has(s.state))
+                    return ok(`Run ${effectiveRunId} is now **${s.state}**.`, { run: s });
+            }
+            return ok(`Stop request sent for run ${effectiveRunId}. State is still queued/running — poll ` +
+                `run_status({ runId: "${effectiveRunId}" }) to confirm.`);
         }
         catch (e) {
             return err(describeError(e));