scenescout 3.16.0 → 3.18.0

package/dist/installer.js

@@ -16,13 +16,118 @@ export const MCP_NAME = "scenescout";
 /** Names this tool's skill and MCP server had before renames; cleaned up on install so the old slash command and a duplicate tool set do not linger. */
 const LEGACY_SKILL_NAMES = ["frontend-tester", "scenecraft"];
 const LEGACY_MCP_NAMES = ["scenecraft"];
+/** Windows' own PATHEXT when the variable is unset. Each entry includes its dot. */
+const WINDOWS_PATH_EXT = ".COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC";
+/** cmd.exe meta characters. A caret in front of one of these keeps it literal. */
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+/** A `.cmd` or `.bat` file. Node refuses to spawn one directly (EINVAL) unless a shell starts it. */
+export function isBatchShim(file) {
+    return /\.(?:cmd|bat)$/i.test(file);
+}
+function escapeCmdMeta(value) {
+    return value.replace(CMD_META, "^$1");
+}
+/**
+ * The file Windows would run for `command`, or null when nothing matches.
+ *
+ * The current directory is tried before PATH. A name that already contains a
+ * dot is tried as written, then with each PATHEXT suffix; a name without a
+ * dot only gains those suffixes. Suffixes stay in PATHEXT order, so an
+ * `.exe` listed ahead of `.cmd` wins when both exist.
+ */
+export function resolveWindowsCommand(command, opts) {
+    const listed = (opts.pathExt?.trim() || WINDOWS_PATH_EXT).split(";").filter((ext) => ext !== "");
+    const exts = path.win32.basename(command).includes(".") ? ["", ...listed] : listed;
+    const rooted = path.win32.isAbsolute(command) || /[\\/]/.test(command);
+    const dirs = rooted ? [""] : [opts.cwd, ...windowsPathDirs(opts.pathEnv)];
+    for (const dir of dirs) {
+        const base = rooted ? (path.win32.isAbsolute(command) ? command : path.win32.join(opts.cwd, command)) : path.win32.join(dir, command);
+        for (const ext of exts) {
+            const candidate = base + ext;
+            if (opts.exists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+function windowsPathDirs(pathEnv) {
+    const dirs = [];
+    for (const raw of pathEnv.split(";")) {
+        const dir = raw.trim();
+        if (!dir)
+            continue;
+        dirs.push(dir.length >= 2 && dir.startsWith('"') && dir.endsWith('"') ? dir.slice(1, -1) : dir);
+    }
+    return dirs;
+}
+/**
+ * One argument on a `cmd /c` line that a batch shim forwards with `%*`.
+ *
+ * Quoted for the program that finally runs (backslashes before a quote follow
+ * CommandLineToArgvW). Every cmd meta character is then caret-escaped twice:
+ * once for `cmd.exe /c`, and once for the shim line that expands `%*`. A JSON
+ * value and a path containing spaces each stay a single argument.
+ */
+function escapeCmdArgument(arg) {
+    let value = `${arg}`;
+    // Backslashes that escape a following quote, then a trailing run that the
+    // wrapping quote would otherwise swallow. The match does not backtrack.
+    value = value.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+    value = value.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    value = escapeCmdMeta(escapeCmdMeta(`"${value}"`));
+    return value;
+}
+/** The string after `cmd.exe /d /s /c`. The outer quotes exist for `/s` to strip. */
+function windowsBatchCommandLine(command, args) {
+    const program = escapeCmdMeta(path.win32.normalize(command));
+    return `"${[program, ...args.map(escapeCmdArgument)].join(" ")}"`;
+}
+/**
+ * How to start `command`. On Windows a resolved `.cmd` or `.bat` goes through
+ * `cmd.exe`, because node will not spawn those itself. Everywhere else, and
+ * for an executable, the command and its arguments pass through unchanged.
+ */
+export function planSpawn(opts) {
+    if (opts.platform === "win32" && opts.resolved && isBatchShim(opts.resolved)) {
+        return {
+            command: opts.comSpec?.trim() || "cmd.exe",
+            args: ["/d", "/s", "/c", windowsBatchCommandLine(opts.resolved, opts.args)],
+            windowsVerbatimArguments: true,
+        };
+    }
+    return { command: opts.command, args: opts.args };
+}
+/** `planSpawn` for this platform, resolving a Windows batch shim before choosing cmd.exe. */
+export function commandSpawnPlan(command, args, opts) {
+    if (opts.platform !== "win32")
+        return { command, args };
+    return planSpawn({
+        command,
+        args,
+        platform: "win32",
+        resolved: resolveWindowsCommand(command, { cwd: opts.cwd, pathEnv: opts.pathEnv ?? "", pathExt: opts.pathExt, exists: opts.exists }),
+        comSpec: opts.comSpec,
+    });
+}
 /** Real runner. `missing` separates "the binary is not installed" from "it ran and failed". */
 export const spawnRunner = (command, args, opts) => {
-    const r = spawnSync(command, args, { encoding: "utf8", timeout: 60_000, cwd: opts?.cwd });
+    const planned = commandSpawnPlan(command, args, {
+        platform: process.platform,
+        cwd: opts?.cwd ?? process.cwd(),
+        pathEnv: process.env.PATH,
+        pathExt: process.env.PATHEXT,
+        comSpec: process.env.ComSpec,
+        exists: (file) => fs.existsSync(file),
+    });
+    const r = spawnSync(planned.command, planned.args, {
+        encoding: "utf8",
+        timeout: 60_000,
+        cwd: opts?.cwd,
+        windowsVerbatimArguments: planned.windowsVerbatimArguments,
+    });
     const code = r.error?.code;
-    // On Windows node refuses to start a .cmd or .bat file directly (EINVAL). For
-    // the caller that is the same situation as a missing binary: nothing ran, and
-    // the command has to be handed to the person instead.
+    // A batch shim is started through cmd.exe above. EINVAL still means a shim
+    // was spawned directly and nothing ran: the same outcome as a missing binary.
     const missing = code === "ENOENT" || (process.platform === "win32" && code === "EINVAL");
     // With `encoding` set, a command that never ran still yields "" for stderr: the error is the only account of it.
     const stderr = r.stderr || (code === "ETIMEDOUT" ? "npm did not finish within 60 s" : r.error ? String(r.error.message) : "");
@@ -295,7 +400,8 @@ export function planCommand(opts) {
         if (mine || !checkout)
             return { action: "present", at: opts.resolved };
     }
-    // npm on Windows is a .cmd shim, which node cannot start directly.
+    // Putting `scenescout` on PATH stays a manual npm command on Windows. Client
+    // registration is separate: spawnRunner starts a `.cmd` shim itself.
     if (opts.platform === "win32")
         return { action: "manual", manual, why: "this step cannot start npm on Windows" };
     const beside = path.join(path.dirname(opts.nodePath), "npm");

package/dist/intake.js

@@ -102,3 +102,164 @@ export function settingsFromAnswers(a) {
 export function introQuestions() {
     return INTAKE_QUESTIONS.map((q, i) => `${i + 1}. ${q.ask}`).join("\n");
 }
+// ── The questions as one form ────────────────────────────────────────────────
+//
+// A client that can show a form (MCP elicitation, form mode) gets the four
+// questions as one, through scout_intake; every other client, and a person who
+// declines or dismisses the form, gets them as text for the agent to ask in
+// chat. Specification: https://modelcontextprotocol.io/specification/2025-11-25/client/elicitation
+// (the version the SDK speaks; the 2026-07-28 revision keeps the same capability,
+// schema subset and three actions). Two of its rules shape this:
+// - a server MUST NOT send a mode the client did not declare, and an empty
+//   `elicitation` capability means form mode only (formElicitationSupported);
+// - a server MUST NOT ask for passwords, API keys or tokens in form mode. The
+//   form asks HOW the person signs in, never with what: the sign-in itself is
+//   scout_login's window.
+/** The tool that asks the questions, as a form where the client can show one. */
+export const INTAKE_TOOL = "scout_intake";
+/**
+ * Whether the client can show a form. Declared `form` says so; an empty
+ * `elicitation` object is form mode by the specification's backwards-compatibility
+ * rule; `url` alone, or no `elicitation` at all, is not.
+ */
+export function formElicitationSupported(capabilities) {
+    const e = capabilities?.elicitation;
+    if (!e || typeof e !== "object")
+        return false;
+    return e.form !== undefined || e.url === undefined;
+}
+const choice = (value, title) => ({ const: value, title });
+const askOf = (id) => INTAKE_QUESTIONS.find((q) => q.id === id).ask;
+/** Every value the form offers for a choice, with the words the person sees. */
+export const FORM_CHOICES = {
+    signIn: [
+        choice("none", "No sign-in"),
+        choice("sso", "Google or Microsoft single sign-on"),
+        choice("password", "An email and password"),
+        choice("one-time-code", "A one-time code"),
+    ],
+    whatToCheck: [
+        choice("everything", "Everything: the whole site"),
+        choice("description", "What I describe below"),
+        choice("tickets", "The tickets I paste below"),
+    ],
+    realData: [choice("yes", "Yes"), choice("no", "No"), choice("unsure", "Not sure")],
+};
+/** What the form says above its fields. */
+export const INTAKE_FORM_MESSAGE = "Four questions before SceneScout starts testing. It never asks for a password here: if the site needs one, a browser window opens later for you to sign in as you normally would.";
+/**
+ * The form, as an `elicitation/create` request's `requestedSchema`: a flat object
+ * of strings and single-choice lists, the only shapes form mode allows. `address`
+ * starts filled in when the agent already knows it. Real data starts at "Not sure",
+ * which tests as carefully as "Yes".
+ */
+export function intakeFormSchema(knownAddress) {
+    const address = knownAddress?.trim();
+    return {
+        type: "object",
+        properties: {
+            address: { type: "string", title: "Address", description: askOf("address"), minLength: 1, ...(address ? { default: address } : {}) },
+            signIn: { type: "string", title: "Sign-in", description: askOf("sign-in"), oneOf: [...FORM_CHOICES.signIn] },
+            whatToCheck: {
+                type: "string",
+                title: "What to check",
+                description: "What should I check?",
+                oneOf: [...FORM_CHOICES.whatToCheck],
+                default: "everything",
+            },
+            details: {
+                type: "string",
+                title: "Description or tickets",
+                description: "Describe what to check in a sentence, or paste the tickets with a line of --- between them. To upload a file of tickets instead, leave this empty and I will ask for it.",
+            },
+            realData: { type: "string", title: "Real data", description: askOf("real-data"), oneOf: [...FORM_CHOICES.realData], default: "unsure" },
+        },
+        required: ["address", "signIn", "whatToCheck", "realData"],
+    };
+}
+const oneOf = (list, value) => list.find((c) => c.const === value)?.const;
+/** Pasted tickets, split on a line of three or more dashes, empty ones dropped. */
+export function splitTickets(text) {
+    return text
+        .split(/^[ \t]*-{3,}[ \t]*$/m)
+        .map((t) => t.trim())
+        .filter(Boolean);
+}
+const SIGN_IN_WORDS = {
+    none: "no sign-in",
+    sso: "Google or Microsoft single sign-on",
+    password: "an email and password",
+    "one-time-code": "a one-time code",
+};
+/**
+ * What a form round comes to. Accepted answers become settings through
+ * settingsFromAnswers. Anything else asks in chat: all four questions when
+ * there was no form or the person turned it down, and only what is still
+ * missing when the form came back without it (tickets to upload, an empty
+ * description). An answer is never guessed.
+ */
+export function intakeFromForm(outcome) {
+    const all = (why) => ({ kind: "ask", questions: [...INTAKE_QUESTIONS], known: [], why });
+    if (outcome.kind === "unsupported")
+        return all("this client cannot show a form");
+    if (outcome.kind === "declined")
+        return all("the person declined the form");
+    if (outcome.kind === "cancelled")
+        return all("the person closed the form without answering");
+    if (outcome.kind === "failed")
+        return all(`the form failed: ${outcome.error}`);
+    const c = outcome.content;
+    const address = typeof c.address === "string" ? c.address.trim() : "";
+    const signIn = oneOf(FORM_CHOICES.signIn, c.signIn);
+    const kind = oneOf(FORM_CHOICES.whatToCheck, c.whatToCheck);
+    const realData = oneOf(FORM_CHOICES.realData, c.realData);
+    const details = typeof c.details === "string" ? c.details.trim() : "";
+    let whatToCheck;
+    // "Everything" with text in the box is a contradiction (the choice starts on everything, so pasted tickets
+    // would be dropped unseen): asked again rather than guessed either way.
+    if (kind === "everything" && !details)
+        whatToCheck = "everything";
+    else if (kind === "description" && details)
+        whatToCheck = { description: details };
+    else if (kind === "tickets" && splitTickets(details).length > 0)
+        whatToCheck = { tickets: splitTickets(details) };
+    const missing = INTAKE_QUESTIONS.filter((q) => (q.id === "address" && !address) || (q.id === "sign-in" && !signIn) || (q.id === "what-to-check" && !whatToCheck) || (q.id === "real-data" && !realData));
+    if (!address || !signIn || !whatToCheck || !realData) {
+        const known = [
+            address ? `Address: ${address}` : "",
+            signIn ? `Sign-in: ${SIGN_IN_WORDS[signIn]}` : "",
+            kind === "everything" && details
+                ? "What to check: everything was chosen, but there is text in the box too"
+                : kind
+                    ? `What to check: ${kind}${whatToCheck ? "" : ", not given yet"}`
+                    : "",
+            realData ? `Real data: ${FORM_CHOICES.realData.find((r) => r.const === realData).title.toLowerCase()}` : "",
+        ].filter(Boolean);
+        return { kind: "ask", questions: missing, known, why: "the form came back without every answer" };
+    }
+    return { kind: "settings", settings: settingsFromAnswers({ address, signIn, whatToCheck, realData }) };
+}
+/** scout_intake's reply as text: the calls to make in order, or the questions to ask in chat. */
+export function intakeReplyText(reply) {
+    if (reply.kind === "ask") {
+        const numbered = reply.questions.map((q, i) => `${i + 1}. ${q.ask}`).join("\n");
+        return [
+            `No settings from a form (${reply.why}). Ask the person ${reply.questions.length === 1 ? "this question" : "these questions"} in chat, in one message, then choose the settings from the answers as the method says.`,
+            ...(reply.known.length > 0 ? ["", "Already answered in the form:", ...reply.known.map((k) => `- ${k}`)] : []),
+            "",
+            numbered,
+        ].join("\n");
+    }
+    const s = reply.settings;
+    const steps = [];
+    if (s.login) {
+        steps.push(`Tell the person: "${s.login.tellUser}"`);
+        steps.push(`Call ${s.login.tool} ${JSON.stringify({ url: s.login.url, role: s.login.role })}, which returns once they are signed in.`);
+    }
+    steps.push(`Call scout_attach ${JSON.stringify(s.attach)}, with projectPath as the method's setup says.`);
+    if (s.readTickets)
+        steps.push(`Once attached, read the tickets: ${s.readTickets.tool} ${JSON.stringify({ text: s.readTickets.text })}.`);
+    if (s.focus)
+        steps.push(`Keep to this area: ${s.focus}`);
+    return ["The person answered the form. Use these settings; do not ask the questions again.", ...steps.map((step, i) => `${i + 1}. ${step}`)].join("\n");
+}

package/dist/mcp-server.js

@@ -53,6 +53,8 @@ import { MAX_UNFILED_NAMED, unfiledDefects } from "./engine/calibration.js";
 import { SessionQueue, withWatchdog } from "./engine/dispatch.js";
 import { FIXTURE_KINDS } from "./engine/fixtures.js";
 import { feedForSession, LIVE_ENV, writeStatusFile, LIVE_TOKEN_FILE, liveEngines, liveTokenFileName, pidAlive, statusFileName, LiveServer, StatusBoard, } from "./engine/live.js";
+import { liveViewUrl, MCP_APP_MIME, paneData, paneText, STATUS_PANE_URI, STATUS_POLL_TOOL, STATUS_TOOL, } from "./engine/status-pane.js";
+import { statusPanePage } from "./engine/status-pane-page.js";
 import { formatBriefs, MAX_LANES, planLanes } from "./engine/brief.js";
 import { decideOpen, OPEN_CHOICES, OPEN_ENV, openChoiceFromEnv, openInBrowser } from "./engine/open.js";
 import { DEFAULT_EXPIRY_MARGIN_MINUTES, DEFAULT_RUN_MINUTES, judgeProfileFile } from "./engine/expiry.js";
@@ -69,7 +71,9 @@ import { chooseProjectFolder, PROJECTS_DIR_ENV, workspaceFromRoots } from "./eng
 import { RECORD_MAX_FRAMES, resolveFrame } from "./engine/replay.js";
 import { describePace, normalizePace } from "./engine/settle.js";
 import { needsTask, taskRefusal, TASK_MAX } from "./engine/task.js";
+import { formElicitationSupported, INTAKE_FORM_MESSAGE, INTAKE_TOOL, intakeFormSchema, intakeFromForm, intakeReplyText } from "./intake.js";
 import { EXPLORE_PROMPT_ARGUMENTS, explorePrompt, loadPlaybook, PLAYBOOK_PROMPT, PLAYBOOK_TOOL, SERVER_INSTRUCTIONS } from "./playbook.js";
+import { livePrompt, loginPrompt, LOGIN_PROMPT, LIVE_PROMPT, LOGIN_PROMPT_ARGUMENTS, LIVE_PROMPT_ARGUMENTS } from "./prompts.js";
 import { formatScan, scanProject } from "./scan.js";
 import { CAPTURE_MARGIN, CAPTURES_DIRNAME, captureFileName, captureResultText, describePicture, EVIDENCE_ENV, EVIDENCE_LIMITS, EVIDENCE_MARGIN, EVIDENCE_MODES, evidenceFrame, evidenceSettings, findingPicturePath, MAX_CAPTURE_MARGIN, RECORD_ENV, recordChoice, returnsInline, } from "./engine/capture.js";
 import { decodePng, fitPicture } from "./engine/png.js";
@@ -346,7 +350,7 @@ function startLiveServer() {
 function liveLine() {
     if (!liveAddress)
         return liveError ? `\nLive view unavailable: ${liveError}` : "";
-    return (`\nLive view: http://127.0.0.1:${liveAddress.port}/${liveAddress.token}/ — give this address to the user so they can watch every session ` +
+    return (`\nLive view: ${liveViewUrl(liveAddress.port, liveAddress.token)} — give this address to the user so they can watch every session ` +
         `(current tool, page thumbnail, optional live stream). It opens on this machine only and cannot act on the run.`);
 }
 /** What each session's attach decided to open (engine/open.ts). scout_report reads it for the report. */
@@ -540,10 +544,51 @@ server.registerTool(PLAYBOOK_TOOL, {
         return errorText(err);
     }
 });
-// The same method as a prompt, for clients that list server prompts as commands.
-// Registered on the protocol server directly: the SDK's prompt helper rejects a
-// request that carries no `arguments` object, which is exactly what a client
-// sends when the person typed none, and every argument here is optional.
+// The start-of-run questions as one form, where the client can show one (MCP
+// elicitation, form mode); otherwise, or when the person declines or closes it,
+// the questions come back as text for the agent to ask in chat. The mapping is
+// intake.ts's; this only shows the form and reports how it ended.
+/** How long the form waits for the person before the questions go back to chat. */
+const INTAKE_FORM_WAIT_MS = 10 * 60_000;
+server.registerTool(INTAKE_TOOL, {
+    description: "Ask the start-of-run questions (the site's address, whether and how to sign in, what to check, whether the site holds real data) when the person gave no settings. " +
+        "Where this client can show a form, the person answers there and this returns the settings to use: the scout_login and scout_attach calls, in order. " +
+        "Otherwise, or when they decline or close the form, it returns the questions for you to ask in chat. Never asks for a password. Touches no browser.",
+    inputSchema: {
+        url: z.string().max(2048).optional().describe("The site's address, when the person already said it: the form starts with it filled in"),
+    },
+}, async ({ url }, extra) => {
+    let outcome;
+    if (!formElicitationSupported(server.server.getClientCapabilities()))
+        outcome = { kind: "unsupported" };
+    else {
+        try {
+            const result = await server.server.elicitInput({ mode: "form", message: INTAKE_FORM_MESSAGE, requestedSchema: intakeFormSchema(url) }, { timeout: INTAKE_FORM_WAIT_MS, signal: extra.signal, relatedRequestId: extra.requestId });
+            outcome =
+                result.action === "accept"
+                    ? { kind: "accepted", content: result.content ?? {} }
+                    : result.action === "decline"
+                        ? { kind: "declined" }
+                        : { kind: "cancelled" };
+        }
+        catch (err) {
+            // A client that advertised forms and then failed one: the questions still get asked, in chat, with why.
+            outcome = { kind: "failed", error: err instanceof Error ? err.message : String(err) };
+            console.error(`[scenescout] ${INTAKE_TOOL}: the form failed, asking in chat instead: ${outcome.error}`);
+        }
+    }
+    try {
+        return { content: [{ type: "text", text: intakeReplyText(intakeFromForm(outcome)) }] };
+    }
+    catch (err) {
+        return errorText(err);
+    }
+});
+// Prompts, for clients that list server prompts as commands. Registered on the
+// protocol server directly: the SDK's prompt helper rejects a request that
+// carries no `arguments` object, which is exactly what a client sends when the
+// person typed none. `explore` and `live` accept that; `login` then says the
+// role is missing. None of them takes a password.
 server.server.registerCapabilities({ prompts: {} });
 server.server.setRequestHandler(ListPromptsRequestSchema, () => ({
     prompts: [
@@ -553,16 +598,36 @@ server.server.setRequestHandler(ListPromptsRequestSchema, () => ({
             description: "Start an exploratory test session: loads the SceneScout method and states the target.",
             arguments: EXPLORE_PROMPT_ARGUMENTS,
         },
+        {
+            name: LIVE_PROMPT,
+            title: "Watch the live view",
+            description: "Return the loopback live-view URL for the current session. Takes no arguments and no password.",
+            arguments: LIVE_PROMPT_ARGUMENTS,
+        },
+        {
+            name: LOGIN_PROMPT,
+            title: "Sign in as a role",
+            description: "Call scout_login for a role and wait the way that tool waits. The person signs in in the window it opens. Takes the role, and the app URL when you have it. Never a password.",
+            arguments: LOGIN_PROMPT_ARGUMENTS,
+        },
     ],
 }));
 server.server.setRequestHandler(GetPromptRequestSchema, (request) => {
-    if (request.params.name !== PLAYBOOK_PROMPT)
-        throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${request.params.name}`);
+    const name = request.params.name;
     let message;
     try {
-        message = explorePrompt(loadPlaybook(PACKAGE_ROOT), request.params.arguments);
+        if (name === PLAYBOOK_PROMPT)
+            message = explorePrompt(loadPlaybook(PACKAGE_ROOT), request.params.arguments);
+        else if (name === LIVE_PROMPT)
+            message = livePrompt(request.params.arguments);
+        else if (name === LOGIN_PROMPT)
+            message = loginPrompt(request.params.arguments);
+        else
+            throw new McpError(ErrorCode.InvalidParams, `Unknown prompt: ${name}`);
     }
     catch (err) {
+        if (err instanceof McpError)
+            throw err;
         throw new McpError(ErrorCode.InvalidParams, err instanceof Error ? err.message : String(err));
     }
     return { messages: [{ role: "user", content: { type: "text", text: message } }] };
@@ -950,7 +1015,7 @@ server.registerTool("scout_attach", {
         let openNote = "";
         if (opening.live && liveAddress && !liveOpened) {
             liveOpened = true;
-            openNote = openForUser("the live view", `http://127.0.0.1:${liveAddress.port}/${liveAddress.token}/`);
+            openNote = openForUser("the live view", liveViewUrl(liveAddress.port, liveAddress.token));
         }
         else if (!opening.live && liveAddress && !openWhySaid) {
             // Once per server, so a person wondering why no window appeared is told how to change it.
@@ -1760,6 +1825,67 @@ server.registerTool("scout_finding", {
         return errorText(err);
     }
 }));
+// ---- The run-status pane: an MCP App (SEP-1865, `io.modelcontextprotocol/ui`, spec 2026-01-26). ----
+// scout_status links the pane through _meta.ui.resourceUri; the pane polls the
+// app-only tool. Neither goes through a session queue: like the live view, a
+// watcher must never wait behind the agent's calls, and both only read.
+function statusPaneData() {
+    const eng = [lastWriter ? engines.get(lastWriter.session) : undefined, ...engines.values()].find((e) => !!e?.memory);
+    const memory = eng?.memory ?? null;
+    let coverage = null;
+    if (eng && memory) {
+        const all = eng.allKnownRoutes();
+        const cov = memory.coverage();
+        coverage = {
+            routesVisited: all.length - eng.unvisitedKnownRoutes().length,
+            routesTotal: all.length,
+            states: cov.states,
+            elementsExercised: cov.elementsExercised,
+            elementsTotal: cov.elementsTotal,
+        };
+    }
+    return paneData({
+        nowMs: Date.now(),
+        version: PKG_VERSION,
+        live: liveAddress,
+        liveError,
+        liveOff: process.env[LIVE_ENV] === "off",
+        sessions: board.list(),
+        findings: memory ? memory.findings : null,
+        runStart: memory?.sessionStart,
+        coverage,
+    });
+}
+function statusResult() {
+    try {
+        const data = statusPaneData();
+        return { content: [{ type: "text", text: paneText(data) }], structuredContent: { ...data } };
+    }
+    catch (err) {
+        return errorText(err);
+    }
+}
+server.registerResource("scenescout-status", STATUS_PANE_URI, {
+    title: "SceneScout run status",
+    description: "The run's sessions, open findings by severity, coverage and the live view's address, refreshed every few seconds.",
+    mimeType: MCP_APP_MIME,
+    // No outside origin: the page is one self-contained document, so the host's restrictive default CSP applies.
+    _meta: { ui: { csp: {}, prefersBorder: true } },
+}, () => ({
+    contents: [{ uri: STATUS_PANE_URI, mimeType: MCP_APP_MIME, text: statusPanePage(PKG_VERSION), _meta: { ui: { csp: {}, prefersBorder: true } } }],
+}));
+server.registerTool(STATUS_TOOL, {
+    title: "Run status",
+    description: "Show the person running you how the run stands: each session's objective and current task, open findings by severity, coverage, and the live view's address. " +
+        "Call it when the user wants to watch or asks how the run is going. A host that renders MCP Apps shows a pane that keeps itself up to date; every other host gets the same as text, and you pass the `Live view:` address on. Takes no input and touches no browser.",
+    // The legacy flat key alongside _meta.ui.resourceUri, as the ext-apps SDK's registerAppTool sets both for hosts that read only the old one.
+    _meta: { ui: { resourceUri: STATUS_PANE_URI }, "ui/resourceUri": STATUS_PANE_URI },
+}, async () => statusResult());
+server.registerTool(STATUS_POLL_TOOL, {
+    title: "Run status (for the pane)",
+    description: `Called by the ${STATUS_TOOL} pane every few seconds to refresh itself. Not for the agent: call ${STATUS_TOOL} instead.`,
+    _meta: { ui: { visibility: ["app"] } },
+}, async () => statusResult());
 server.registerTool("scout_coverage", {
     description: "Show exploration coverage: states visited, which elements remain unexercised, which options of a dropdown used this run no session has chosen yet, and which forms seen this run no session has submitted with every text field blank. Use to decide where to explore next and when the level's budget is satisfied. In a parallel run it shows this session's own work by default — the routes it reached this run and the forms it saw — so one lane is not handed another's gaps; scope:\"project\" shows every session's, each form and route tagged with the sessions that saw it.",
     inputSchema: {

package/dist/playbook.js

@@ -77,7 +77,7 @@ export function explorePrompt(playbook, args) {
     }
     // Nothing asked for at all: the person has chosen no settings, so the run starts with the plain questions.
     if (given("url") === undefined && level === undefined && given("focus") === undefined) {
-        return `${playbook}\n\n---\n\nRun an exploratory test session following the method above. I gave no settings: before setup, ask me these questions in one message, then choose the settings from my answers as the method says.\n${introQuestions()}`;
+        return `${playbook}\n\n---\n\nRun an exploratory test session following the method above. I gave no settings: before setup, call scout_intake, which asks me these questions in a form where this client can show one; when it returns them as text instead, ask me them in one message, then choose the settings from my answers as the method says.\n${introQuestions()}`;
     }
     const asks = [
         given("url") ? `Target: ${given("url")}` : "Target: ask me for the URL of the running app, or find it from the project.",

package/dist/prompts.js

@@ -0,0 +1,106 @@
+/**
+ * MCP prompts other than the testing method.
+ *
+ * `explore` lives in playbook.ts because its text is the skill. `live` and
+ * `login` are short instructions: hand back the loopback live-view address,
+ * or call scout_login for a role. Neither accepts a password. The protocol
+ * server in mcp-server.ts lists all three; the SDK prompt helper is not used,
+ * because it rejects a request that omits `arguments`.
+ */
+import { validateRoleName } from "./engine/profiles.js";
+export const LIVE_PROMPT = "live";
+export const LOGIN_PROMPT = "login";
+/** `live` takes nothing. A password field here would ask the person for a credential the live view does not use. */
+export const LIVE_PROMPT_ARGUMENTS = [];
+/** `login` names a role, and the app's address when the caller has one. There is no password argument. */
+export const LOGIN_PROMPT_ARGUMENTS = [
+    {
+        name: "role",
+        description: "The name to save the sign-in under, e.g. admin. scout_attach { role } uses it afterwards. Not a password.",
+        required: true,
+    },
+    {
+        name: "url",
+        description: "The app's address or its sign-in page, when you have it, e.g. http://localhost:3000. Omit when the conversation already has it.",
+        required: false,
+    },
+];
+/**
+ * Argument names that would carry a credential. Matched on the name only, so
+ * a refusal can name the argument without repeating the value the client sent.
+ */
+const CREDENTIAL_ARGUMENT = /^(?:password|passwd|pass|secret|token|credential|credentials|otp|totp|mfa|apikey|api_key)$/i;
+function refuseCredentialArguments(args) {
+    if (!args)
+        return;
+    for (const key of Object.keys(args)) {
+        if (CREDENTIAL_ARGUMENT.test(key)) {
+            throw new Error(`this prompt does not take ${key}: never pass a password or any other credential`);
+        }
+    }
+}
+/**
+ * The opening message of the `live` prompt. The address itself is printed by
+ * the engine on tool results (`Live view: http://127.0.0.1:…`); this only
+ * tells the model to hand that line back. Any argument is refused.
+ */
+export function livePrompt(args) {
+    refuseCredentialArguments(args);
+    const given = Object.keys(args ?? {}).filter((key) => args?.[key] !== undefined);
+    if (given.length > 0)
+        throw new Error("the live prompt takes no arguments");
+    return ("Return the loopback live-view URL for the current session.\n\n" +
+        "The live view is one address for every session of this run. It is served on 127.0.0.1 only, and a tool result prints it as a line starting " +
+        '"Live view: http://127.0.0.1:". If this conversation does not already contain that line, call scout_session with no arguments and read it from the result. ' +
+        "Calling scout_session with a name would change the default session; do not pass one.\n\n" +
+        "Reply with that address. Where you can open a URL for the user, you may open it as well. " +
+        "If the result says the live view is unavailable, say so and do not invent an address.\n\n" +
+        "Do not ask for a password or any other credential. This prompt takes none.");
+}
+/** An http(s) address with no userinfo. The raw string is returned only after that check, so a refusal never quotes a password embedded in it. */
+function publicHttpUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new Error("url must be an http or https address");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:")
+        throw new Error(`only http and https URLs can be opened (got ${url.protocol})`);
+    if (url.username || url.password)
+        throw new Error("put no credentials in the URL: sign in in the window instead");
+    return raw;
+}
+/**
+ * The opening message of the `login` prompt: call scout_login for the role and
+ * wait the way that tool already waits. A missing or illegal role is refused.
+ * A password argument is refused without the value being repeated.
+ */
+export function loginPrompt(args) {
+    refuseCredentialArguments(args);
+    const given = args ?? {};
+    const unknown = Object.keys(given).filter((key) => key !== "role" && key !== "url");
+    if (unknown.length > 0)
+        throw new Error("the login prompt takes role and url only");
+    const checked = validateRoleName(typeof given.role === "string" ? given.role.trim() : given.role);
+    if (!checked.ok)
+        throw new Error(checked.error);
+    const url = publicHttpUrlOrNone(typeof given.url === "string" ? given.url.trim() : "");
+    // JSON so a quote in the address cannot rewrite the instruction. The address has already been refused when it carries credentials.
+    const where = url
+        ? `Call scout_login with ${JSON.stringify({ role: checked.role, url })}.`
+        : `Call scout_login with role ${JSON.stringify(checked.role)} and the app's address as url. ` +
+            "Use the address this conversation already has; if it has none, ask for the app's address or its sign-in page, then pass that as url.";
+    return (`Sign in as the role "${checked.role}" by calling scout_login. ` +
+        "Do not ask for a password, and do not type credentials yourself: the person signs in in the browser window the tool opens.\n\n" +
+        'Tell them first, in plain words: "A browser window is opening. Sign in there as you normally would; it closes by itself once you are in."\n\n' +
+        `${where}\n\n` +
+        "The call returns once they are signed in and the login is saved, or after its wait with the window still open. " +
+        `When it is still waiting, call scout_login again with the same role ("${checked.role}") to keep waiting, once they say they are done or to check. ` +
+        "Never pass a password.");
+}
+/** `publicHttpUrl("")` would throw. An omitted url is the optional argument left out, not an illegal address. */
+function publicHttpUrlOrNone(raw) {
+    return raw ? publicHttpUrl(raw) : "";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scenescout",
-  "version": "3.16.0",
+  "version": "3.18.0",
   "description": "SceneScout — exploratory UI testing for AI coding agents. An MCP server that gives any agent (Claude Code, Cursor, VS Code Copilot, Codex, Gemini CLI and others) a structured view of a running web app, always-on oracles, a network-level write policy, memory across runs and a gap-checked report.",
   "license": "MIT",
   "author": "brunoboto96",
@@ -111,14 +111,14 @@
     "dedup-bench": "tsx scripts/dedup-bench.ts"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@modelcontextprotocol/sdk": "^1.31.0",
     "playwright": "^1.63.0",
     "zod": "^3.25.0"
   },
   "devDependencies": {
     "@changesets/cli": "3.0.3",
     "@types/node": "^20.19.0",
-    "prettier": "3.9.8",
+    "prettier": "3.9.9",
     "tsx": "^4.23.15",
     "typescript": "^5.9.3",
     "yaml": "^2.9.1"