@capagents/forgeqe 2.4.0 → 2.4.2

package/dist/web/assets/rotate-ccw-BizUsxuR.js

@@ -0,0 +1 @@
+import{Pt as e}from"./index-KUNDUjo0.js";var t={name:`arrow-left`,size:24,node:[[`path`,{d:`m12 19-7-7 7-7`,key:`1l729n`}],[`path`,{d:`M19 12H5`,key:`x3x0zl`}]]};t.node;var n=e(t),r={name:`rotate-ccw`,size:24,node:[[`path`,{d:`M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8`,key:`1357e3`}],[`path`,{d:`M3 3v5h5`,key:`1xhq8a`}]]};r.node;var i=e(r);export{n,i as t};

package/dist/web/assets/sticky-note-CFIxnO7K.js

@@ -0,0 +1 @@
+import{Pt as e}from"./index-KUNDUjo0.js";var t={name:`sticky-note`,size:24,node:[[`path`,{d:`M21 9a2.4 2.4 0 0 0-.706-1.706l-3.588-3.588A2.4 2.4 0 0 0 15 3H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2z`,key:`1dfntj`}],[`path`,{d:`M15 3v5a1 1 0 0 0 1 1h5`,key:`6s6qgf`}]]};t.node;var n=e(t);export{n as t};

package/dist/web/assets/terminal-BnhGgg6d.js

@@ -0,0 +1 @@
+import{Pt as e}from"./index-KUNDUjo0.js";var t={name:`terminal`,size:24,node:[[`path`,{d:`M12 19h8`,key:`baeox8`}],[`path`,{d:`m4 17 6-6-6-6`,key:`1yngyt`}]]};t.node;var n=e(t);export{n as t};

package/dist/web/assets/trash-CtWVl2Xk.js

@@ -0,0 +1 @@
+import{Pt as e}from"./index-KUNDUjo0.js";var t={name:`trash`,size:24,node:[[`path`,{d:`M10 11v6`,key:`nco0om`}],[`path`,{d:`M14 11v6`,key:`outv1u`}],[`path`,{d:`M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6`,key:`miytrc`}],[`path`,{d:`M3 6h18`,key:`d0wm0j`}],[`path`,{d:`M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2`,key:`e791ji`}]],aliases:[`trash-2`]};t.node;var n=e(t);export{n as t};

package/dist/web/assets/trending-up-BnzWZEhg.js

@@ -0,0 +1 @@
+import{Pt as e}from"./index-KUNDUjo0.js";var t={name:`trending-down`,size:24,node:[[`path`,{d:`M16 17h6v-6`,key:`t6n2it`}],[`path`,{d:`m22 17-8.5-8.5-5 5L2 7`,key:`x473p`}]]};t.node;var n=e(t),r={name:`trending-up`,size:24,node:[[`path`,{d:`M16 7h6v6`,key:`box55l`}],[`path`,{d:`m22 7-8.5 8.5-5-5L2 17`,key:`1t1m79`}]]};r.node;var i=e(r);export{n,i as t};

package/dist/web/assets/when-CHnpLdYw.js

@@ -0,0 +1 @@
+function e(e){let t=e?Date.parse(e):NaN;if(Number.isNaN(t))return``;let n=Math.max(0,(Date.now()-t)/1e3);if(n<60)return`just now`;if(n<3600)return`${Math.floor(n/60)} min ago`;if(n<21600)return`${Math.floor(n/3600)} h ago`;let r=new Date(t);return r.toDateString()===new Date().toDateString()?r.toLocaleTimeString([],{hour:`2-digit`,minute:`2-digit`}):n<518400?r.toLocaleString([],{weekday:`short`,hour:`2-digit`,minute:`2-digit`}):r.toLocaleDateString([],{day:`numeric`,month:`short`})}function t(e,t=new Date){let n=e?new Date(e):null;if(!n||Number.isNaN(n.getTime()))return`Older`;let r=new Date(t.getFullYear(),t.getMonth(),t.getDate()).getTime();return n.getTime()>=r?`Today`:n.getTime()>=r-864e5?`Yesterday`:n.getTime()>=r-5184e5?`Earlier this week`:`Older`}export{t as n,e as t};

package/dist/web/index.html

@@ -5,9 +5,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="referrer" content="no-referrer" />
     <title>ForgeQE</title>
-    <script type="module" crossorigin src="/assets/index-Bkx3fVbr.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/status-CL_clA0J.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-DSEYuBEd.css">
+    <script type="module" crossorigin src="/assets/index-KUNDUjo0.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BI_5kNwE.css">
   </head>
   <body>
     <div id="root"></div>

package/docs/ARCHITECTURE.md

@@ -172,8 +172,9 @@ shell / forgeqe run ──► openBrain ──► agent runtime session (forgeqe
 | `card.ts` | `Card` (`status`, `title`, `stats`, `body`) and `cardText`. `codeCard`, `healCard`, and `roundCard` build cards from the same lines as the terminal summaries |
 | `mcp/server.ts` | JSON-RPC for MCP by hand: `initialize` (protocol 2025-06-18, 2025-03-26, 2024-11-05, with `instructions`), `ping`, `tools/list`, `tools/call`, `notifications/cancelled`. `serveHttp`: Streamable HTTP on 127.0.0.1, checking the bearer token in constant time (`tokenMatches`) and refusing requests whose `Origin` is not this machine (`originAllowed`), so a web page cannot call the tools; tool calls answer as an event stream with a progress notification every 10 s and a keep-alive every 15 s, so the agent runtime's per-call timeout (which resets on progress) never fires during a long suite. `serveStdio`: newline-delimited JSON-RPC for `forgeqe mcp`; closing stdin aborts running calls. `localToolServer`: a server over HTTP with a fresh token and the agent runtime's MCP entry for it, shared by the brain and the healing session |
 | `mcp/git.ts` | `pushBranch`: finds the default branch (`symbolic-ref refs/remotes/<remote>/HEAD`, else `ls-remote --symref`), refuses it and `main`/`master`, checks the name with `git check-ref-format`, and runs `git push --set-upstream <remote> HEAD:refs/heads/<name>` without force. `setCiSecret`: `gh secret set NAME` with the value on stdin, or `az pipelines variable create\|update --secret true` with the value in `AZURE_DEVOPS_EXT_PIPELINE_VAR_<NAME>`; the value is scrubbed from any error |
-| `mcp/external.ts` | `externalMcp` turns `sources:` and `mcp:` into agent runtime MCP entries: `azure_devops` (`npx -y @azure-devops/mcp <org> -a pat\|azcli -d <domains>`), `atlassian` (`uvx mcp-atlassian` with `JIRA_URL` and `JIRA_USERNAME` + `JIRA_API_TOKEN` or `JIRA_PERSONAL_TOKEN`, plus `CONFLUENCE_*` when `sources.confluence` is set, `TOOLSETS=default`; or the hosted Rovo server at `mcp.atlassian.com/v2/mcp` with Basic auth, which also covers Confluence on the same site), `confluence` (`uvx mcp-atlassian` for Confluence alone when Jira's server doesn't cover it), and every `mcp:` server, which replaces a built-in one of the same name. Secrets are `{env:NAME}` references that the agent runtime substitutes; values that must be derived (base64 of `forgeqe:<PAT>` for Azure DevOps, of `email:token` for Rovo) are put in `FORGEQE_*` variables of ForgeQE's own environment before the agent runtime server starts. A system whose server can't start here (no npx or uvx, missing token, Azure DevOps Server, Rovo on Server/DC) is listed with the reason. The servers get a 120 s timeout, which also covers the first `npx`/`uvx` download |
+| `mcp/external.ts` | `externalMcp` turns `sources:` and `mcp:` into agent runtime MCP entries: `azure_devops` (`npx -y @azure-devops/mcp <org> -a pat\|azcli -d <every group in ADO_GROUPS>`, with `hints` from `adoHints`: each prefix's words and keywords, and the `mcp_domains` prefixes on every turn), `atlassian` (`uvx mcp-atlassian` with `JIRA_URL` and `JIRA_USERNAME` + `JIRA_API_TOKEN` or `JIRA_PERSONAL_TOKEN`, plus `CONFLUENCE_*` when `sources.confluence` is set, `TOOLSETS=all`; or the hosted Rovo server at `mcp.atlassian.com/v2/mcp` with Basic auth, which also covers Confluence on the same site), `confluence` (`uvx mcp-atlassian` for Confluence alone when Jira's server doesn't cover it), and every `mcp:` server, which replaces a built-in one of the same name. Secrets are `{env:NAME}` references that the agent runtime substitutes; values that must be derived (base64 of `forgeqe:<PAT>` for Azure DevOps, of `email:token` for Rovo) are put in `FORGEQE_*` variables of ForgeQE's own environment before the agent runtime server starts. A system whose server can't start here (no npx or uvx, missing token, Azure DevOps Server, Rovo on Server/DC) is listed with the reason. The servers get a 120 s timeout, which also covers the first `npx`/`uvx` download |
 | `cases/dashboards.ts` | `createAdoDashboard` for the `create_ado_dashboard` tool, since Microsoft's Azure DevOps MCP server has no dashboard or saved-query tools: runs each widget's WIQL once (`$top=1`) so a bad query fails before anything is written, saves it under `Shared Queries/ForgeQE` (creating the folder, PATCHing a query of the same name), then POSTs the dashboard (`7.1-preview.3`, team-scoped when a team is given) with count tiles (`QueryScalarWidget`, `{queryId, queryName}`) across the top, then work item lists (`WitViewWidget`, `{query: {queryId, queryName}}`) and markdown two to a row. Widget `settings` are JSON strings, as the API requires |
+| `cases/adopr.ts` | `createAdoPullRequest` for the `create_ado_pull_request` tool, since the default MCP tool groups leave out `repositories` and `query_api` only reads: `branchRef` checks each branch against git's ref-name rules before anything is sent, the repository is read by name or id, both refs must exist (`refs?filter=heads/…`), an active pull request between the same refs is returned (`existing: true`) instead of a second one, then it POSTs `pullrequests` with a default title of "Merge <source> into <target>" |
 | `cases/wiki.ts` | `writeAdoWikiPage` for the `write_ado_wiki_page` tool, since the MCP server's wiki tools need an existing wiki: picks the named wiki or the project wiki, creating `<Project>.wiki` (`type: projectWiki`, project id from `_apis/projects`) when the project has none, PUTs missing parent pages empty, then PUTs the page with `If-Match` set to its ETag when it already exists. Code wikis get `versionDescriptor` for their first published branch |
 | `cases/api.ts` | `queryApi` for the `query_api` tool: GET under the Azure DevOps organization (and its `vsrm`/`vssps`/`almsearch` hosts, with `api-version=7.1` added) or the Jira site, and Xray Cloud GraphQL queries (mutations refused). Absolute URLs on other hosts are refused, so credentials only go to their own system. Answers over 40,000 characters are cut |
 
@@ -191,7 +192,9 @@ Every model call carries the definitions of the tools the agent has, so the agen
 
 | Module | Contents |
 |--------|----------|
-| `mcp/scope.ts` | `CapabilityScope`, one per agent session. `beginTurn(text)` picks the turn's capabilities and returns the per-prompt `tools` switches (`forgeqe_<tool>: true\|false`). The picks are: the core (`setup-help`, `test-apps`), `agent.capabilities.always`, the ones `use_capabilities` asked for, those used in the last `STICKY_TURNS` (3) turns, and up to `MAX_PICKED` (4) from `scoreRequest`. `scoreRequest` makes no model call: it matches keywords and tool names, URLs (the browser), issue keys (test cases), and the names of the active environment's apps (by kind). A capability whose required apps or system are missing (`usableCapabilities`) is not picked from words alone, and nothing is picked from `agent.capabilities.off`. When nothing matches, `browser-goals` is the fallback. `request` (from `use_capabilities`) refuses unknown and switched-off ids and queues the added ones in `takePending`. `listedTools` is the list for MCP clients. `capabilityIndex` is the short list of capabilities in the agent's prompt |
+| `mcp/scope.ts` | `CapabilityScope`, one per agent session. `beginTurn(text)` picks the turn's capabilities and returns the per-prompt `tools` switches (`forgeqe_<tool>: true\|false`). The picks are: the core (`setup-help`, `test-apps`), `agent.capabilities.always`, the ones `use_capabilities` asked for, those used in the last `STICKY_TURNS` (3) turns, and up to `MAX_PICKED` (4) from `scoreRequest`. `scoreRequest` makes no model call: it matches keywords and tool names, URLs (the browser), issue keys (test cases), and the names of the active environment's apps (by kind). A capability whose required apps or system are missing (`usableCapabilities`) is not picked from words alone, and nothing is picked from `agent.capabilities.off`. When nothing matches, `browser-goals` is the fallback. `request` (from `use_capabilities`) refuses unknown and switched-off ids and queues the added ones in `takePending`. `listedTools` is the list for MCP clients. `capabilityIndex` is the short list of capabilities in the agent's prompt. Other MCP servers' `ToolGroup`s are switched the same way: `always` ones every turn, a group whose keywords match the request as whole words (they do not count against `MAX_PICKED`; when the request names a system, by a group's `system` words such as "github" or "azure devops", only that system's groups), the ones `use_capabilities` asked for, and one whose tool ran in the last turns (`used` takes the runtime name, from `onToolResult`). `toggles` adds a switch per tool of each group; opencode applies a prompt's `tools` to MCP tools by name, so a switched-off group's definitions are not sent (tests/brain-groups.e2e.test.ts) |
+| `mcp/discover.ts` | `discoverTools` asks every server for its tools (initialize, tools/list) as the runtime starts it: a local command through `spawnPlan` (an argument list; cmd.exe quoting on Windows) with its `{env:}` values filled in and ForgeQE's private variables left out, or a remote address (streamable HTTP, JSON or SSE). The list is kept in `~/.forgeqe/cache/mcp-tools/<hash>.json` (mode 0600) for `LIST_TTL_MS` (a week); the hash is of what the server runs and the names of its variables, never a value or the server's name. `serverGroups` groups each list; a server that does not answer is left out, so its tools stay on |
+| `mcp/toolgroups.ts` | `groupTools` makes a server's groups from its tool names alone. Words of a name are split (snake and camel case), made singular, and verbs and fillers dropped; two words that only ever come together are one ("pull request"). A server whose tools mostly share a first word is split by it; otherwise, and for a prefix group over `MAX_GROUP` tools or `MAX_GROUP_TOKENS`, each tool goes to the rarest word at least 3 of them share, then the rest to words 2 share, the remainder to a catch-all whose keywords are its members' words. Keywords are the group's word or phrase, phrases from its names, plurals, and `SPELLED` (wit: work item); broad words (`WEAK`) are never one alone. A server under `SMALL_SERVER_TOKENS` is one group, always on. `ServerHints` only add titles, keywords and the always-on groups (`mcp/adogroups.ts` for Azure DevOps) |
 | `mcp/captools.ts` | `use_capabilities`: adds capabilities for the rest of the session |
 | `mcp/routing.ts` | `createRouter` passes every ForgeQE tool that runs to `scope.used` |
 | `brain/index.ts` | `ask` starts each turn with `beginTurn` and prompts with its switches. When `use_capabilities` added capabilities during the turn, it continues the same request with them, at most `MAX_SCOPE_CONTINUATIONS` (2) times. `FORGEQE_TOOL_SCOPE=off` turns the scope off |

package/docs/user-guide.html

@@ -396,7 +396,7 @@ forgeqe docs --copy ./docs   # copy the guide, the architecture page, and the re
 <div class="area"><a class="area-name" href="#area-api"><span class="mono">API</span></a><ul class="tiles"><li><a class="tile" href="#cap-api-testing"><b>API and contract testing</b><span>Turn the last run's API calls into tests</span></a></li></ul></div>
 <div class="area"><a class="area-name" href="#area-quality"><span class="mono">Quality</span></a><ul class="tiles"><li><a class="tile" href="#cap-accessibility-performance"><b>Accessibility and page performance</b><span>Is the checkout page accessible?</span></a></li><li><a class="tile" href="#cap-visual-comparison"><b>Visual comparison with baselines</b><span>What changed visually since the last run?</span></a></li><li><a class="tile" href="#cap-defect-intelligence"><b>Defect intelligence: trends and prediction</b><span>Which defects keep coming back?</span></a></li></ul></div>
 <div class="area"><a class="area-name" href="#area-release"><span class="mono">Release</span></a><ul class="tiles"><li><a class="tile" href="#cap-release-readiness"><b>Requirement coverage and release readiness</b><span>Are we ready to release?</span></a></li><li><a class="tile" href="#cap-reports"><b>Reports you can share</b><span>Create a release report for all projects</span></a></li></ul></div>
-<div class="area"><a class="area-name" href="#area-systems"><span class="mono">Systems</span></a><ul class="tiles"><li><a class="tile" href="#cap-systems"><b>Work with Azure DevOps, Jira, GitHub, and Confluence</b><span>Show the open bugs in this sprint</span></a></li><li><a class="tile" href="#cap-system-data"><b>Read any data in Azure DevOps, Jira, Xray, and Confluence</b><span>Are there open pull requests in any repository of QI-Claims?</span></a></li></ul></div>
+<div class="area"><a class="area-name" href="#area-systems"><span class="mono">Systems</span></a><ul class="tiles"><li><a class="tile" href="#cap-systems"><b>Work with Azure DevOps, Jira, GitHub, and Confluence</b><span>Show the open bugs in this sprint</span></a></li><li><a class="tile" href="#cap-system-data"><b>Read any data in Azure DevOps, Jira, Xray, and Confluence, and open Azure DevOps pull requests</b><span>Are there open pull requests in any repository of QI-Claims?</span></a></li></ul></div>
 <h3 class="band-title">Not supported</h3>
 <ul class="plainlist"><li><b>Load, stress, or soak testing with many simultaneous users</b>. Instead: per-page Core Web Vitals with budgets.</li><li><b>Penetration testing or dynamic security scanning</b>. Instead: security findings in pull request reviews.</li></ul>
 </section>
@@ -916,6 +916,7 @@ forgeqe run &quot;Run the cases in smoke.yaml and don't post results&quot; --pla
 <tr><td><code>answer</code></td><td><code>id</code> (from an <code>ask</code>), <code>choice</code> (an option id, or <code>null</code> to cancel)</td><td>Answers the pending question</td></tr>
 <tr><td><code>continue</code></td><td><code>id</code> (from a <code>wait</code>), <code>ok</code> (<code>true</code> = Done, continue; <code>false</code> = Cancel)</td><td>Ends the pending wait</td></tr>
 <tr><td><code>stop</code></td><td></td><td>Stops the running turn (Esc or <code>/stop</code> in the shell). Nothing when idle</td></tr>
+<tr><td><code>settings</code></td><td><code>headed</code> and/or <code>writeTests</code> (each <code>true</code> or <code>false</code>, nothing else)</td><td>Changes the chat's choices from now on: whether browser runs are shown (as <code>--headed</code>), and whether passed runs become tests (as <code>--no-code</code>, off). The next browser run uses them; the agent is told of a change with your next message. Answered with <code>settings</code></td></tr>
 <tr><td><code>close</code></td><td></td><td>Stops any turn, closes the agent, stops monitors and the containers it started, writes <code>closed</code>, exits 0</td></tr>
 </tbody>
 </table></div>
@@ -926,8 +927,9 @@ forgeqe run &quot;Run the cases in smoke.yaml and don't post results&quot; --pla
 <tr><th><code>type</code></th><th>Fields</th><th>When</th></tr>
 </thead>
 <tbody>
-<tr><td><code>ready</code></td><td><code>protocol</code> (1), <code>version</code>, <code>cwd</code>, <code>writeTests</code>, <code>profile</code> (<code>name</code> and <code>provider</code>, never a key)</td><td>Once, after the config is loaded and checked, before stdin is read</td></tr>
+<tr><td><code>ready</code></td><td><code>protocol</code> (1), <code>version</code>, <code>cwd</code>, <code>writeTests</code>, <code>headed</code>, <code>profile</code> (<code>name</code> and <code>provider</code>, never a key)</td><td>Once, after the config is loaded and checked, before stdin is read</td></tr>
 <tr><td><code>turn_start</code></td><td><code>id</code></td><td>A message was accepted</td></tr>
+<tr><td><code>settings</code></td><td><code>headed</code>, <code>writeTests</code></td><td>After a <code>settings</code> line: the choices now in force</td></tr>
 <tr><td><code>agent</code></td><td><code>id</code>, <code>event</code>: a <code>CodeEvent</code> (<code>stream</code>, <code>say</code>, <code>start</code>, <code>tool</code>, <code>plan</code>, <code>usage</code>, <code>context</code>, <code>test</code>, <code>info</code>, …)</td><td>While the turn runs</td></tr>
 <tr><td><code>tool</code></td><td><code>id</code>, <code>event</code>: a <code>ToolEvent</code> (<code>run-start</code>, <code>run-event</code>, <code>run-done</code>, <code>suite-*</code>, <code>card</code>, <code>info</code>, <code>agent</code>, <code>code-*</code>, …)</td><td>While the turn runs; <code>id</code> is <code>null</code> for a background monitor between turns</td></tr>
 <tr><td><code>ask</code></td><td><code>id</code> (<code>ask-N</code>), <code>turn</code>, <code>question</code> (<code>title</code>, <code>detail</code>, <code>lines</code>, <code>options[{id, label}]</code>)</td><td>A tool asks you to choose</td></tr>
@@ -947,7 +949,7 @@ forgeqe run &quot;Run the cases in smoke.yaml and don't post results&quot; --pla
 <li>Exit codes: 0 after <code>closed</code>, 1 after <code>fatal</code>, 2 after SIGINT or SIGTERM (the turn is stopped and the agent closed first).</li>
 </ul>
 <p>A complete exchange (<code>→</code> stdout, <code>←</code> stdin; <code>t</code> left out):</p>
-<pre><code class="language-text">→ {&quot;v&quot;:1,&quot;seq&quot;:1,&quot;type&quot;:&quot;ready&quot;,&quot;protocol&quot;:1,&quot;version&quot;:&quot;2.3.11&quot;,&quot;cwd&quot;:&quot;/srv/studio/users/ana/workspace&quot;,&quot;writeTests&quot;:true,&quot;profile&quot;:{&quot;name&quot;:&quot;copilot&quot;,&quot;provider&quot;:&quot;github_copilot&quot;}}
+<pre><code class="language-text">→ {&quot;v&quot;:1,&quot;seq&quot;:1,&quot;type&quot;:&quot;ready&quot;,&quot;protocol&quot;:1,&quot;version&quot;:&quot;2.3.11&quot;,&quot;cwd&quot;:&quot;/srv/studio/users/ana/workspace&quot;,&quot;writeTests&quot;:true,&quot;headed&quot;:false,&quot;profile&quot;:{&quot;name&quot;:&quot;copilot&quot;,&quot;provider&quot;:&quot;github_copilot&quot;}}
 ← {&quot;type&quot;:&quot;message&quot;,&quot;id&quot;:&quot;m1&quot;,&quot;text&quot;:&quot;Run SHOP-12 on staging&quot;}
 → {&quot;v&quot;:1,&quot;seq&quot;:2,&quot;type&quot;:&quot;turn_start&quot;,&quot;id&quot;:&quot;m1&quot;}
 → {&quot;v&quot;:1,&quot;seq&quot;:3,&quot;type&quot;:&quot;agent&quot;,&quot;id&quot;:&quot;m1&quot;,&quot;event&quot;:{&quot;type&quot;:&quot;code&quot;,&quot;kind&quot;:&quot;stream&quot;,&quot;id&quot;:&quot;p1&quot;,&quot;text&quot;:&quot;I'll run SHOP-12&quot;}}
@@ -1791,6 +1793,15 @@ Signing in stays <code>/auth</code> and <code>forgeqe login</code>; <code>forgeq
 </table></div>
 <p><strong>Your copy or ForgeQE's.</strong> <code>.forgeqe-manifest.json</code> in each folder records what was copied. A copy you have not changed still counts as ForgeQE's, so it keeps getting ForgeQE's improvements when you update; once you edit it, yours is used. When ForgeQE's version changes after you edited yours, ForgeQE says so at start-up. Running <code>init</code> again adds what is missing and never overwrites an edited file (with <code>--force</code> it refreshes only unchanged copies).</p>
 <p><strong>Prompts.</strong> Each file has a short header (<code>name</code>, <code>description</code>, <code>used_by</code>, <code>kind</code>) and the prompt; <code>{{&gt; name}}</code> includes another prompt (<code>test-rules</code> is included in the test, reviewer, and healing prompts, so one edit changes all three). ForgeQE looks in <code>prompts.dir</code>, then <code>.forgeqe/prompts/</code>, then <code>~/.forgeqe/prompts/</code> (for every project), then its own. Changes take effect on the next run or session.</p>
+<p><strong>Your team's prompts.</strong> Instructions of your own for chosen agents go in <code>.forgeqe/prompts/team/&lt;name&gt;.md</code> (or <code>~/.forgeqe/prompts/team/</code> for every project; a name in the project wins). The header has <code>name</code>, <code>description</code>, and <code>for</code>: the agents' prompts it joins (<code>brain</code> for ForgeQE's agent, <code>test-agent</code> for Scribe, <code>browser-extra</code> for the browser agent, and so on). Its text is added at the end of those prompts, under &quot;Your team's instructions&quot;, as written: it is not a template and includes nothing. The web app's Prompts page adds, edits and removes them, and shows each agent's whole prompt with them included; <code>forgeqe prompts show &lt;prompt&gt;</code> shows it in the terminal.</p>
+<pre><code class="language-markdown">---
+name: tag-work-items
+description: &quot;Tests carry the work item they cover&quot;
+for: test-agent, browser-extra
+---
+Tag every test with the Azure DevOps work item it covers.
+If the request names no work item, ask for it.
+</code></pre>
 <pre><code class="language-bash">forgeqe prompts                     # every prompt, what it is for, and where it comes from
 forgeqe prompts show test-agent     # the prompt as the agent gets it (includes expanded; --raw for the file)
 forgeqe prompts diff test-rules     # how your copy differs from ForgeQE's
@@ -3889,7 +3900,7 @@ tokens and the like) show as <code>•••</code> in results. A check compares
 </code></pre>
 <p>The Activities panel has one line for each verdict and attempt, and <code>forgeqe</code> commands outside the terminal UI print the same blocks.</p>
 <p>Scribe cannot edit ForgeQE's files or run folders, and cannot run <code>git clean</code>, <code>git reset --hard</code>, <code>git stash</code>, <code>git restore</code>, or <code>git checkout -- &lt;path&gt;</code>. If it still removes a file that existed before the job, or reverts your uncommitted edits, ForgeQE puts the file back after that attempt and tells the agent.
-8. The job is done when ForgeQE's run passes with a browser and the reviewer approves. It stops as a failure after <code>max_attempts</code> attempts, when the job passes <code>code.max_tokens</code>, when the reviewer rejects a passing test twice, if the review cannot finish, when the test fails the same way three times in a row (the same output apart from numbers such as timings and line numbers; the second time, Scribe is told its change did not change the failure and to look at the failing step before changing code), or straight away on an auth, API, or context-limit error from the model.</p>
+8. The job is done when ForgeQE's run passes with a browser, the reviewer approves, and the test passes again unchanged until it has passed <code>code.confirm_runs</code> times in a row (default 3; <code>1</code> runs it once). A test that passes and then fails is flaky: the next attempt is told which run failed and why, and to make that step wait for the page. It stops as a failure after <code>max_attempts</code> attempts, when the job passes <code>code.max_tokens</code>, when the reviewer rejects a passing test twice, if the review cannot finish, when the test fails the same way three times in a row (the same output apart from numbers such as timings and line numbers; the second time, Scribe is told its change did not change the failure and to look at the failing step before changing code), or straight away on an auth, API, or context-limit error from the model.</p>
 <p><code>blocked</code> is a last resort. The first time the agent reports that the app blocks it, ForgeQE sends it back to compare its browser with ForgeQE's and fix the difference; only a second blocked report, with what it compared, ends the job as blocked.</p>
 <p>The transcript shows the handover and Scribe's work as it goes; files it writes or edits are marked ✎:</p>
 <pre><code>┃
@@ -3967,7 +3978,7 @@ forgeqe run &quot;...&quot; --no-code                                # no tests
 </ul>
 <p><strong>When the flow cannot be reproduced.</strong> If ForgeQE's own replay of the run could not reach the run's final page and Scribe's test fails too, Scribe is told where the replay stopped and what was open on the page, since that is usually a pop-up, consent banner or ad the browser agent closed, or state its browser already had (signed in, items in a cart), and gets another attempt to handle it. The job stops, saying which replayed step failed and why, only when the test then fails the same way again, instead of spending its remaining attempts on a flow no script can repeat as recorded.</p>
 <p><strong>Why a test failed.</strong> When ForgeQE's run of Scribe's test fails, the ✗ line and the next attempt say why in the test's own words: dotnet test's Error Message, pytest's <code>E</code> lines, or the error with its Expected and Received values (Playwright, Jest, JUnit), not the runner's summary line.</p>
-<p><strong>Keeping Scribe's cost down.</strong> ForgeQE reads the repository's test setup itself before Scribe starts (stack, settings files and their browser values, the test id attribute, base classes, page objects and their methods, one test command) and hands it over, so Scribe does not discover it with dozens of file reads. Each attempt after the first starts a fresh session from a summary of the job (handoff, files changed, what each attempt did, the latest failure), so later attempts cost about what the first did. The summary has a &quot;Tried already, and did not work&quot; list: for each failed attempt, what Scribe said it did (it reports each change in <code>tried</code>), how it failed, the locator the test was waiting for and the element that covered it and took the click, both read from the test's output, and whether an earlier attempt already failed on that locator. Scribe must not try those again in the same form and must say what it does differently. <code>forgeqe heal</code> keeps the same list across its attempts. <code>code.max_attempts</code> (default 3) and <code>code.max_tokens</code> (default 1,500,000; <code>0</code> turns it off) cap a job, and the token budget is checked during an attempt too, so one long attempt is stopped when the total passes it. The reviewer sorts its issues into correctness (the test does not test what the goal says, or not reliably) and coding standards (test data or credentials in a page object, naming, hard waits, leftovers). Coding standards never fail a test that works: it is accepted, and the coding agent gets one more round (not counted in <code>max_attempts</code>) to fix them; if that round breaks the test, ForgeQE puts back the version that passed and lists the standards issues in the notes (<code>code.tidy: false</code> skips the round). A test the reviewer rejects twice for correctness stops the job with its issues, since that usually means the test case and the page disagree. When a test passed and the reviewer sent it back, and the changes for the review then break it (or the attempts or the token budget run out first), ForgeQE puts back the version that passed: the result is passed but not approved, with the reviewer's issues in the notes, so you get a working test to finish instead of none. Under each step, the handoff shows that step's part of the page (its section and neighbours, from the replay's page snapshot) instead of whole snapshots. When a test fails, ForgeQE shows the failing element on the test's page at the failure and on the replay's page, so most failures are fixed without opening a browser. Scribe's live browser is switched on only when the same failure repeats, and it does not send a page snapshot after every click or keystroke. <code>code.max_steps</code> (default 50) caps the tool calls in one of Scribe's turns. <code>code.review_profile</code> runs the reviewer on a cheaper llms.json profile.</p>
+<p><strong>Keeping Scribe's cost down.</strong> ForgeQE reads the repository's test setup itself before Scribe starts (stack, settings files and their browser values, the test id attribute, base classes, page objects and their methods, one test command) and hands it over, so Scribe does not discover it with dozens of file reads. Each attempt after the first starts a fresh session from a summary of the job (handoff, files changed, what each attempt did, the latest failure), so later attempts cost about what the first did. The summary has a &quot;Tried already, and did not work&quot; list: for each failed attempt, what Scribe said it did (it reports each change in <code>tried</code>), how it failed, the locator the test was waiting for and the element that covered it and took the click, both read from the test's output, and whether an earlier attempt already failed on that locator. Scribe must not try those again in the same form and must say what it does differently. <code>forgeqe heal</code> keeps the same list across its attempts. <code>code.max_attempts</code> (default 3) and <code>code.max_tokens</code> (default 1,500,000; <code>0</code> turns it off) cap a job, and the token budget is checked during an attempt too, so one long attempt is stopped when the total passes it. Cached input counts at its share of the profile's input price (a session re-reads its own context, and that is most of its input), and in full when no cached price is known, such as with another <code>code.model</code>. The reviewer sorts its issues into correctness (the test does not test what the goal says, or not reliably) and coding standards (test data or credentials in a page object, naming, hard waits, leftovers). Coding standards never fail a test that works: it is accepted, and the coding agent gets one more round (not counted in <code>max_attempts</code>) to fix them; if that round breaks the test, ForgeQE puts back the version that passed and lists the standards issues in the notes (<code>code.tidy: false</code> skips the round). A test the reviewer rejects twice for correctness stops the job with its issues, since that usually means the test case and the page disagree. When a test passed and the reviewer sent it back, and the changes for the review then break it (or the attempts or the token budget run out first), ForgeQE puts back the version that passed: the result is passed but not approved, with the reviewer's issues in the notes, so you get a working test to finish instead of none. Under each step, the handoff shows that step's part of the page (its section and neighbours, from the replay's page snapshot) instead of whole snapshots. When a test fails, ForgeQE shows the failing element on the test's page at the failure and on the replay's page, so most failures are fixed without opening a browser. Scribe's live browser is switched on only when the same failure repeats, and it does not send a page snapshot after every click or keystroke. <code>code.max_steps</code> (default 50) caps the tool calls in one of Scribe's turns. <code>code.review_profile</code> runs the reviewer on a cheaper llms.json profile.</p>
 <p><strong>Scribe's rulebook: the same mistake once.</strong> When a job passes after a failed test run or a reviewer's change, Scribe's report gives up to three one-line rules that would have avoided the mistake (&quot;Wait for the cart badge with toHaveText before clicking Checkout; it updates after a request&quot;). ForgeQE keeps them in <code>.forgeqe/scribe-rules.json</code> in the repository, and every attempt of later jobs, and every healing session, starts with them. A lesson from a job that did not pass, or that passed at once, is not kept: only a fix that worked becomes a rule. The book stays small, since it is sent with each model call: at most 15 rules of one line each; a lesson learned again is merged into its rule (shown as &quot;learned 3 times&quot;) instead of added; when it is full, the rule confirmed least and longest ago goes, and a rule not learned again for 180 days expires. The rules are the coding agent's own words, so a rule with a link, something like a token, a destructive command, or wording that tells an agent to drop its instructions is refused, and the agents are told they are hints that never override their instructions or the team's guardrails. Commit the file to share the rules with the team and see each change in review; edit or delete a rule there (the agents cannot change <code>.forgeqe</code>). ForgeQE says each new rule as it learns it (<code>Learned for next time: …</code>). <code>code.rulebook: false</code> turns it off.</p>
 </div>
 </section>
@@ -4620,10 +4631,10 @@ forgeqe bi build --from //share/qa-reports # this machine's runs plus every bund
 <tr><th>System</th><th>MCP server</th><th>Needs</th></tr>
 </thead>
 <tbody>
-<tr><td>Azure DevOps Services</td><td>Microsoft's <a href="https://github.com/microsoft/azure-devops-mcp" rel="noopener">Azure DevOps MCP server</a> (<code>npx @azure-devops/mcp</code>), with all its tools: work items, boards, test plans, pipelines, repos, wiki pages, search, and security alerts</td><td>Node.js, and <code>ADO_PAT</code> or <code>az login</code></td></tr>
+<tr><td>Azure DevOps Services</td><td>Microsoft's <a href="https://github.com/microsoft/azure-devops-mcp" rel="noopener">Azure DevOps MCP server</a> (<code>npx @azure-devops/mcp</code>), with all its tools, each turn getting the groups it needs: work items, boards, test plans, pipelines, repos, wiki pages, search, and security alerts</td><td>Node.js, and <code>ADO_PAT</code> or <code>az login</code></td></tr>
 <tr><td>Jira Cloud, Server/Data Center</td><td><a href="https://github.com/sooperset/mcp-atlassian" rel="noopener">mcp-atlassian</a> (<code>uvx</code>), with issues, JQL search, comments, and transitions. <code>mcp: rovo</code> uses <a href="https://github.com/atlassian/atlassian-mcp-server" rel="noopener">Atlassian's hosted server</a> instead (Cloud, and an admin must allow API tokens)</td><td>uv; <code>JIRA_EMAIL</code> and <code>JIRA_API_TOKEN</code> (Cloud) or a personal access token (Server/DC)</td></tr>
 <tr><td>Confluence</td><td>mcp-atlassian, shared with Jira (or its own when Jira isn't set up); Atlassian's hosted server covers it on the same site</td><td><code>confluence: true</code> on a Jira Cloud site, or <code>confluence.url</code> + tokens</td></tr>
-<tr><td>GitHub</td><td>GitHub's <a href="https://github.com/github/github-mcp-server" rel="noopener">hosted MCP server</a> with the repos, issues, pull requests, and Actions toolsets (<code>sources.github.toolsets</code> changes them), on in a repository with a GitHub remote or when <code>sources.github</code> is set. GitHub issues are also a test case source (<code>github:#12</code>, <code>github:acme/shop#12,#13</code>, <code>github:label=login</code>, <code>github:q=login in:title</code>): results go back as issue comments, and <code>sources.bugs.system: github</code> files bugs as issues. GitHub has no API to upload a screenshot to an issue, so a bug names the run folder instead</td><td><code>GITHUB_TOKEN</code>, or the GitHub CLI's sign-in (<code>forgeqe auth login github</code>)</td></tr>
+<tr><td>GitHub</td><td>GitHub's <a href="https://github.com/github/github-mcp-server" rel="noopener">hosted MCP server</a> with every toolset, each turn getting the groups of tools it needs (<code>sources.github.toolsets</code> limits them), on in a repository with a GitHub remote or when <code>sources.github</code> is set. GitHub issues are also a test case source (<code>github:#12</code>, <code>github:acme/shop#12,#13</code>, <code>github:label=login</code>, <code>github:q=login in:title</code>): results go back as issue comments, and <code>sources.bugs.system: github</code> files bugs as issues. GitHub has no API to upload a screenshot to an issue, so a bug names the run folder instead</td><td><code>GITHUB_TOKEN</code>, or the GitHub CLI's sign-in (<code>forgeqe auth login github</code>)</td></tr>
 <tr><td>Xray, TestRail, Zephyr Scale, qTest</td><td>none; ForgeQE's API</td><td><code>XRAY_CLIENT_ID</code> / <code>XRAY_CLIENT_SECRET</code>, <code>TESTRAIL_EMAIL</code> / <code>TESTRAIL_API_KEY</code>, <code>ZEPHYR_API_TOKEN</code>, <code>QTEST_TOKEN</code></td></tr>
 <tr><td>Anything else</td><td>servers you add under <code>mcp:</code></td><td></td></tr>
 </tbody>
@@ -4640,6 +4651,7 @@ mcp:
 <p>Whatever has no MCP server, or whose server didn't connect, goes through ForgeQE's own tools, which call the REST APIs directly: <code>find_test_cases</code> and <code>run_test_cases</code> for test cases and posting results back, <code>read_confluence</code> for Confluence pages, and <code>query_api</code> to read anything else from Azure DevOps, Jira, Xray, or Confluence. <code>query_api</code> only reads (GET requests and Xray GraphQL queries) and only reaches the configured hosts. <code>sources.azure_devops.mcp: false</code> or <code>sources.jira.mcp: false</code> uses the API only.</p>
 <p>Microsoft's Azure DevOps server can't create dashboards, so &quot;create a dashboard in QI-Payments with all defects and this sprint's stories&quot; goes through ForgeQE's <code>create_ado_dashboard</code>: one shared query per widget under <code>Shared Queries/ForgeQE</code>, then a dashboard with a work item list or count tile for each. Your <code>ADO_PAT</code> needs Work Items (read and write) and permission to edit dashboards. Chart widgets aren't made through the API; for those the agent uses the browser, signed in to <code>dev.azure.com</code> with a saved login.</p>
 <p>Its wiki tools can only write into a wiki that already exists, so wiki pages go through ForgeQE's <code>write_ado_wiki_page</code>. If the project has no wiki yet, that tool creates the project wiki first, along with any missing parent pages. The PAT needs Wiki (read and write).</p>
+<p>Pull requests are opened with ForgeQE's <code>create_ado_pull_request</code> (&quot;create a PR from feature/cart to main in the shop repository&quot;), since the <code>repositories</code> tool group is not loaded by default. It checks that both branches exist, and returns an active pull request between the same branches instead of opening a second one. The PAT needs Code (read and write).</p>
 <p>Requirements work too: &quot;write and run test cases for the checkout rules page in Confluence&quot; makes the agent read the page, write one case per rule or acceptance criterion (with the main negative paths), show them, and run them. It saves them into a test system only when you ask.</p>
 <p>The agent creates or changes items (a bug, a comment, a status change) only when you ask it to; bugs for failed cases come from <code>sources.bugs</code>, not from the agent.</p>
 </div>
@@ -4647,12 +4659,12 @@ mcp:
 </div>
 </article>
 <article class="spec feat" id="cap-system-data">
-<div class="hd"><span class="mono">Systems</span><h3>Read any data in Azure DevOps, Jira, Xray, and Confluence</h3></div>
-<p class="ds">Reads through a system's REST API what its MCP tools do not cover: pull requests and repositories, test plans and suites, classic releases, and anything else in Azure DevOps, Jira, Xray, or Confluence. Given on every turn once a system is set up, so the agent never turns to the browser or the shell to read it.</p>
+<div class="hd"><span class="mono">Systems</span><h3>Read any data in Azure DevOps, Jira, Xray, and Confluence, and open Azure DevOps pull requests</h3></div>
+<p class="ds">Reads through a system's REST API what its MCP tools do not cover: pull requests and repositories, test plans and suites, classic releases, and anything else in Azure DevOps, Jira, Xray, or Confluence. Opens Azure DevOps pull requests, which the API reads cannot. Given on every turn once a system is set up, so the agent never turns to the browser or the shell for them.</p>
 <div class="facts">
-<div class="fact"><span class="mono">Ask it</span><ul class="asks"><li>Are there open pull requests in any repository of QI-Claims?</li><li>List the test plans in QI-MobileBanking with their suites</li></ul></div>
+<div class="fact"><span class="mono">Ask it</span><ul class="asks"><li>Are there open pull requests in any repository of QI-Claims?</li><li>List the test plans in QI-MobileBanking with their suites</li><li>Create a pull request from demo_mai_qiclaims to main in the QI-Claims Typescript repository</li></ul></div>
 <div class="fact"><span class="mono">What it needs</span><ul class="needs"><li><span class="need req">Required</span><span>Azure DevOps or Jira or Xray or Confluence: set up under sources: in forgeqe.yaml, or sign in with /auth</span></li></ul></div>
-<div class="fact"><span class="mono">Tools</span><p class="tools"><code>query_api</code></p></div>
+<div class="fact"><span class="mono">Tools</span><p class="tools"><code>query_api</code> <code>create_ado_pull_request</code></p></div>
 </div>
 <div class="detail"><span class="mono">In detail</span>
 <p class="see">See <a href="#doc-readme-azure-devops-jira-and-other-systems">Azure DevOps, Jira, and other systems</a> (from the README).</p>
@@ -4665,14 +4677,21 @@ mcp:
 <h3>MCP</h3>
 <div class="prose"></div>
 <section class="doc sub" id="doc-how_to_use-servers-forgeqes-agent-connects-to"><h4>Servers ForgeQE's agent connects to</h4><div class="prose"><p>When ForgeQE's agent starts, it connects to an MCP server for each system set up under <code>sources:</code>. The server settings come from the same place as everything else: the organization and project, the site URL, and the names of the environment variables that hold the tokens. You don't write MCP config for these.</p>
-<p><strong>Azure DevOps.</strong> Microsoft's <a href="https://github.com/microsoft/azure-devops-mcp" rel="noopener">Azure DevOps MCP server</a>, run as <code>npx -y @azure-devops/mcp &lt;org&gt; -a pat -d core work work-items pipelines</code>: projects and teams, iterations and boards, work items, and pipelines. Every tool's definition goes to the model with each request, so ForgeQE loads only these groups (about 19 tools, roughly 9.5K tokens, against about 18K for all of them); its own tools cover test plans, wiki pages, dashboards, and pull request reviews, and <code>query_api</code> reads anything else, such as classic releases. The organization comes from <code>org_url</code> (<code>https://dev.azure.com/acme</code> or <code>https://acme.visualstudio.com</code>). ForgeQE passes the PAT from <code>token_env</code> (default <code>ADO_PAT</code>) the way the server wants it; without a PAT it uses your <code>az login</code> session. Its tools are <code>azure_devops_*</code>. <code>mcp_domains</code> adds groups: <code>test-plans</code>, <code>repositories</code> (repos, branches, pull requests), <code>wiki</code>, <code>search</code> (code, wikis, and work items), <code>advanced-security</code>, or <code>[all]</code>. It needs Node.js. Azure DevOps Server (on-premises) isn't supported by Microsoft's server, so it uses ForgeQE's API.</p>
+<p><strong>Every tool, without paying for every tool.</strong> Each server is started with everything it has: Azure DevOps with all its tool groups, Jira and Confluence with <code>TOOLSETS=all</code>, GitHub with every toolset. Every tool given to the model is sent with each of its requests (GitHub's are about 79K tokens, Jira's and Confluence's about 29K, Azure DevOps' about 21K), so a turn gets only the groups of tools its request needs, the way it gets ForgeQE's own capabilities:</p>
+<ul>
+<li>ForgeQE asks each server for its tools when the session starts and keeps the list for a week (<code>~/.forgeqe/cache/mcp-tools</code>), then groups them by their names. No server needs a table of its own: tools named by prefix (<code>repo_…</code>, <code>wit_…</code>, <code>jira_…</code>) are grouped by prefix, and a large prefix again by what its tools are about (Jira's sprints, boards, versions); tools named verb first (<code>list_pull_requests</code>) by what they act on (pull requests, issues, Dependabot alerts). A group is named <code>&lt;server&gt;:&lt;group&gt;</code>, such as <code>github:pull-request</code> or <code>atlassian:jira-sprint</code>.</li>
+<li>A turn gets a group when its request names what the group is about (&quot;create a PR&quot;, &quot;the current sprint&quot;, &quot;dependabot alerts&quot;), when its tools ran in the last turns, or when the agent asks for it with <code>use_capabilities</code>: every group is in the list of capabilities the agent has, so none is out of reach and the browser is never the way round a missing tool. A request that names a system (&quot;the GitHub repository&quot;, &quot;in Azure DevOps&quot;) gets that system's groups from its words, not another's.</li>
+<li>A small server (under about 3K tokens) is one group, on every turn. A server ForgeQE could not ask keeps all its tools on every turn, as before.</li>
+<li><code>agent.capabilities.always</code> and <code>off</code> take group ids too: <code>always: [github:issue]</code>, <code>off: [github:copilot]</code>.</li>
+</ul>
+<p><strong>Azure DevOps.</strong> Microsoft's <a href="https://github.com/microsoft/azure-devops-mcp" rel="noopener">Azure DevOps MCP server</a>, run with every tool group it has: projects and teams (<code>azure-devops:core</code>), iterations and boards (<code>azure-devops:work</code>), work items (<code>azure-devops:wit</code>), pipelines (<code>azure-devops:pipeline</code>), repositories and pull requests (<code>azure-devops:repo</code>), wiki (<code>azure-devops:wiki</code>), test plans (<code>azure-devops:testplan</code>), search (<code>azure-devops:search</code>), and security alerts (<code>azure-devops:advsec</code>). The first four are on every turn (about 21 tools, roughly 10.7K tokens); the others come as described above. ForgeQE's own tools cover dashboards, wiki pages in a project without a wiki, and opening pull requests (<code>create_ado_pull_request</code>) and reviewing them, and <code>query_api</code> reads anything else, such as classic releases. The organization comes from <code>org_url</code> (<code>https://dev.azure.com/acme</code> or <code>https://acme.visualstudio.com</code>). ForgeQE passes the PAT from <code>token_env</code> (default <code>ADO_PAT</code>) the way the server wants it; without a PAT it uses your <code>az login</code> session. Its tools are <code>azure_devops_*</code>. <code>mcp_domains</code> says which groups are on every turn (default <code>[core, work, work-items, pipelines]</code>; <code>[all]</code> for every group, at about 21K tokens a request); <code>agent.capabilities.off</code> switches a group off for good (<code>[azure-devops:advsec]</code>). It needs Node.js. Azure DevOps Server (on-premises) isn't supported by Microsoft's server, so it uses ForgeQE's API.</p>
 <pre><code class="language-yaml">sources:
   azure_devops:
     org_url: https://dev.azure.com/acme   # the MCP server takes the organization, not a project
     # project: Shop                       # optional: limit ForgeQE's own API calls to one project
     token_env: ADO_PAT
     mcp: true                     # false: API only
-    mcp_domains: [core, work, work-items, pipelines, repositories]   # optional: the default four, plus repos
+    mcp_domains: [core, work, work-items, pipelines, repositories]   # optional: groups on every turn; the others come when needed
 </code></pre>
 <p>Microsoft's server has no dashboard tools and can't save queries. Ask for a dashboard (&quot;create a dashboard in QI-Payments with all defects in every state and the current sprint's stories&quot;) and ForgeQE's own <code>create_ado_dashboard</code> tool does it through the REST API with <code>ADO_PAT</code>: it runs each WIQL query once to check it, saves it as a shared query under <code>Shared Queries/ForgeQE</code> (updating one of the same name), and creates a team or project dashboard with a work item list or count tile per query, plus optional markdown text. The PAT needs Work Items (read and write) and permission to edit dashboards. Chart widgets are not made through the API; for those the agent uses the browser, which has to be signed in to <code>dev.azure.com</code> (<code>forgeqe login &lt;name&gt;</code> with a login for it under <code>logins:</code>).</p>
 <p>Microsoft's wiki tools (<code>azure_devops_wiki</code>, <code>azure_devops_wiki_upsert_page</code>) only work in a wiki that already exists. In a project without one they answer &quot;No wiki found&quot;. Ask for a wiki page and ForgeQE's <code>write_ado_wiki_page</code> tool writes it through the REST API instead. If the project has no wiki, the tool creates the project wiki (<code>&lt;Project&gt;.wiki</code>) first, then any missing parent pages (empty), then the page itself. A page that already exists is replaced. Code wikis are written on their published branch. The PAT needs Wiki (read and write). A login added to <code>forgeqe.yaml</code> while ForgeQE is running is picked up the next time the agent lists logins or signs in.</p>

package/evals/prompts/brain/browser-test-intent.yaml

@@ -0,0 +1,30 @@
+id: browser-test-intent
+title: A flow the user asks to test is a test, and its goal asks only for what the page can show
+# The Booking.com log: sent as a task (so no test was written), with a per-night price the result cards never show,
+# and a guest count the user never gave.
+input: |
+  Role: A browser testing agent who searches travel sites.
+
+  Objective: Search Booking.com for hotels near Heathrow Airport, with check-in tomorrow, check-out five days later, and daily cost under £100.
+
+  Context:
+  - Site: Booking.com.
+  - Location: Heathrow Airport.
+  - Dates: check-in tomorrow; check-out five days later.
+  - Price limit: less than £100 per day.
+
+  Output format: A short list of matching hotels, with the hotel name, daily price, total price, distance note, and booking link.
+needs: []
+# browser_run is not allowed: the call is refused, and still observed with its arguments (no browser starts).
+allow: [capabilities, tool_help]
+checks:
+  - id: runs-as-test
+    tools_any: ["forgeqe_browser_run:test"]
+  - id: never-a-task
+    tools_none: ["forgeqe_browser_run:task"]
+  - id: gives-the-total-too
+    field: browser_goals
+    matches: "500"
+  - id: adds-no-guest-count
+    field: browser_goals
+    not_matches: "\\b(1|one) adult"

package/forgeqe.example.yaml

@@ -180,9 +180,10 @@ code:
   # test_command: npx playwright test   # the repo's test command, for forgeqe heal; default: the agent finds it
   max_attempts: 3            # test runs before giving up (also healing attempts); each attempt after the first starts a fresh session from a summary
   # rulebook: false          # Scribe keeps rules learned from its own fixed mistakes in .forgeqe/scribe-rules.json (default on)
-  # max_tokens: 1500000      # stop a coding job past this many tokens (cached included) and report how far it got
+  # max_tokens: 1500000      # stop a coding job past this many tokens and report how far it got; cached input counts at its share of the input price
   # review_profile: azure-mini  # llms.json profile for the reviewer, which only reads and judges: a cheaper model is enough
   test_timeout_seconds: 600  # per test run
+  confirm_runs: 3            # passes in a row a new test needs before it counts as passing (catches a flaky test before it is handed over); 1 runs it once
   stall_after: 5             # stop the coding agent when one command it runs has failed this many times
   replay: true               # before the coding agent starts, run the steps as a Playwright script and hand over what worked and where it failed
   live_browser: true         # once a step fails, the coding agent looks at that page in a Playwright browser instead of building tests to look
@@ -260,7 +261,7 @@ sources:
   #   # project: Shop                       # optional: limit ForgeQE's own test, sprint, and bug calls to one project. Or ADO_PROJECT. * or all means every project.
   #   token_env: ADO_PAT                    # PAT with Test Management + Work Items (read & write)
   #   mcp: true                             # Microsoft's Azure DevOps MCP server (needs npx); false: API only
-  #   # mcp_domains: [core, work, work-items, pipelines]   # the default; add test-plans, repositories, wiki, search, advanced-security, or use [all]
+  #   # mcp_domains: [core, work, work-items, pipelines]   # groups on every turn (the default); repositories, wiki, test-plans, search and advanced-security come when a request needs them. [all]: every group on every turn
   # jira:
   #   url: https://acme.atlassian.net       # or JIRA_URL; Server/Data Center URLs work too
   #   email_env: JIRA_EMAIL                 # Cloud only
@@ -292,7 +293,7 @@ sources:
   # github:                                 # GitHub issues as test cases (github:#12, github:label=login) and bugs;
   #   repo: acme/shop                       # also turns on GitHub's MCP server (on anyway in a repo with a GitHub remote)
   #   token_env: GITHUB_TOKEN               # default; without it, the GitHub CLI's sign-in (forgeqe auth login github)
-  #   toolsets: [repos, issues, pull_requests, actions]   # the MCP server's tool groups; mcp: false turns it off
+  #   toolsets: [repos, issues, pull_requests, actions]   # limit the MCP server's toolsets (default: all, each turn getting the groups it needs); mcp: false turns it off
   # bugs:                                   # a bug per defect; still failing: a comment on the open bug
   #   system: jira                          # jira | azure_devops | github
   #   project: SHOP                         # Jira project key; GitHub owner/repo (Azure DevOps uses azure_devops.project)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capagents/forgeqe",
-  "version": "2.4.0",
+  "version": "2.4.2",
   "description": "ForgeQE: a browser agent CLI that runs goals and test cases in local Chrome or Chromium, or BrowserStack and TestMu AI/LambdaTest when configured, and turns passing runs into tests in your repo",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

package/prompts/brain.md

@@ -26,7 +26,7 @@ A message can also be a task specification with the parts Role, Objective, Conte
 **Tools** (ForgeQE tools; the client adds the forgeqe_ prefix):
 - Each ForgeQE tool comes with its own description. Read it to select the tool.
 - Some playbooks are not in this prompt. The index under "Playbooks" names them. The first result of their tools gives each one, and you MUST obey it.
-- browser_run: set purpose to test for a flow of the application under test. Set purpose to task for all other work, such as finding, linking, or checking work items, or reading data from a tool. A task never becomes an automated test.
+- browser_run: set purpose to test for a flow of the application under test, and for any flow on a website that the user wants tested or automated: the message says test, verify, automate, or script, or its role is a testing agent. That is so also when it asks for the data the flow finds, such as a list of results. Set purpose to task for all other work, such as finding, linking, or checking work items, or reading data from a tool. A task never becomes an automated test.
 - attach_to_work_item: the only way to put a file from a run on a work item or an issue. The Azure DevOps MCP server cannot upload files.
 - A test passes only when run_test, write_test, or heal_tests says so.
 - query_api only reads. set_ci_secret takes the name of a variable, never its value.
@@ -112,6 +112,7 @@ Read data from Azure DevOps, Jira, Xray, Confluence, and other systems in this s
 - The browser MUST be signed in to dev.azure.com. When no saved login covers it, use logins with sign_in first, and add the login to forgeqe.yaml when it is missing.
 - For a wiki page, you MUST use write_ado_wiki_page, not the browser. It works also when the project has no wiki.
 - The MCP wiki tools answer "No wiki found" for a project without a wiki. This answer is not a reason to use the browser.
+- For a pull request in Azure Repos, you MUST use create_ado_pull_request, not the browser. query_api is read-only for Azure DevOps; that is not a reason to use the browser.
 
 ### Test cases
 - To run test cases from these systems, files, or text, you MUST use run_test_cases. It turns each case into a browser goal, writes the reports, and sends the results back.
@@ -179,6 +180,8 @@ For "an end-to-end test for story 1234", "combine these cases into one flow", or
 ### Browser runs
 - A browser_run goal is the complete instruction that the browser agent follows. It MUST give each value and each setting that the user named (dates, places, filters, sort order), and what to check.
 - The goal MUST NOT have your questions, alternatives, or reasoning. You MUST remove all doubt before you call it.
+- The goal MUST NOT add values that the user did not give, such as a number of guests or rooms. Leave the site's default.
+- The goal MUST ask only for what the page can show. When the user gives a limit per unit (per night, per item, per month) and the site can show the total for the whole stay or order, give both in the goal: the limit per unit and the total that it means (5 nights under £100 a night is a total under £500). The agent then uses the one that the page shows.
 - A run with outcome assertion_failed did all the steps and found an expected result that is not true. failed_expectations gives what was expected and what the page shows.
 - That is a correct result: a failed test case. You MUST report it as a failed test, with the expected and the actual result.
 - You MUST NOT run it again, look for the value in other places, or change the expectation. Run again only the runs that could not do their steps.

package/py/forgeqe_engine/flowmatch.py

@@ -55,6 +55,65 @@ def _norm(text: Any) -> str:
     return " ".join(str(text or "").split()).lower()
 
 
+_MONTHS = {
+    m: i
+    for i, names in enumerate(
+        (("jan", "january"), ("feb", "february"), ("mar", "march"), ("apr", "april"), ("may",), ("jun", "june"), ("jul", "july"),
+         ("aug", "august"), ("sep", "sept", "september"), ("oct", "october"), ("nov", "november"), ("dec", "december")),
+        1,
+    )
+    for m in names
+}
+_MONTH = r"(jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|june?|july?|aug(?:ust)?|sept?(?:ember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)"
+_ISO_DATE = re.compile(r"\b(\d{4})[-/.](\d{1,2})[-/.](\d{1,2})\b")
+_NUM_DATE = re.compile(r"\b(\d{1,2})[/.](\d{1,2})[/.](\d{2,4})\b")
+_DAY_MONTH = re.compile(rf"\b(\d{{1,2}})(?:st|nd|rd|th)?\s+(?:of\s+)?{_MONTH}\b")
+_MONTH_DAY = re.compile(rf"\b{_MONTH}\.?\s+(\d{{1,2}})(?:st|nd|rd|th)?\b")
+
+
+def dates(text: Any) -> Set[Tuple[int, int]]:
+    """
+    The calendar days a text names, as (month, day): "2026-10-29", "Thursday, 29 October 2026", "Oct 29", "29/10/2026"
+    (read both ways). Years are left out: a calendar's label and a task can write them differently, or not at all.
+    """
+    s = str(text or "").lower()
+    out: Set[Tuple[int, int]] = set()
+
+    def add(month: int, day: int) -> None:
+        if 1 <= month <= 12 and 1 <= day <= 31:
+            out.add((month, day))
+
+    for _, m, d in _ISO_DATE.findall(s):
+        add(int(m), int(d))
+    for a, b, _ in _NUM_DATE.findall(s):
+        add(int(b), int(a))
+        add(int(a), int(b))
+    for d, m in _DAY_MONTH.findall(s):
+        add(_MONTHS[m], int(d))
+    for m, d in _MONTH_DAY.findall(s):
+        add(_MONTHS[m], int(d))
+    return out
+
+
+def _superseded(steps: Sequence[Dict[str, Any]], describe: Describe) -> Set[int]:
+    """
+    Indexes of steps that type into a control the same flow types into again later with another value: the recording
+    changed its mind there ("London", later "Heathrow Airport"), so the first value was never the task's.
+    """
+    last: Dict[str, str] = {}
+    out: Set[int] = set()
+    infos = [describe(s) for s in steps]
+    for i in range(len(infos) - 1, -1, -1):
+        info = infos[i]
+        if info.get("kind") != "input" or info.get("secret"):
+            continue
+        field_key, value = _norm(info.get("label")), _norm(info.get("value"))
+        if field_key in last and last[field_key] != value:
+            out.add(i)
+        last.setdefault(field_key, value)
+    return out
+
+
 def step_key(info: Dict[str, Any]) -> str:
     """The same step across recorded tasks: what it does, on which control, with which value."""
     return "|".join((str(info.get("kind") or ""), _norm(info.get("label")), _norm(info.get("value"))))
@@ -76,10 +135,16 @@ def borrowable(
     A step other tasks also took is borrowed only while the flow is still in its opening (before the first step this
     task names), and only when it types no value: a banner or a menu is common, the data a task enters is its own.
     A step marked `never` (a page script, an upload, an API call) ends what is borrowed.
+
+    A step that names a date (a calendar day, a typed date) is borrowed only when the task names that date too, and a
+    value the flow later typed over in the same control is not borrowed: both are the other task's data.
     """
     goal_words = words(goal)
+    goal_named = {w for w in goal_words if not w.isdigit()}
+    goal_dates = dates(goal)
     goal_text = _norm(goal)
     common = common or Counter()
+    superseded = _superseded(steps, describe)
     taken = 0
     useful = 0
     opening = True
@@ -89,6 +154,11 @@ def borrowable(
         kind = str(info.get("kind") or "")
         if info.get("never"):
             break
+        if n - 1 in superseded:
+            break
+        step_dates = dates(info.get("label")) | dates(info.get("value"))
+        if step_dates and not step_dates <= goal_dates:
+            break
         if info.get("neutral"):
             taken = n if useful else taken
             continue
@@ -106,7 +176,8 @@ def borrowable(
         signing_in = bool(info.get("secret"))
         if not ok:
             named_value = bool(value_words) and value_words <= goal_words
-            named_label = bool(label_words & goal_words)
+            # A number alone (a year, a day) does not name a control: "Monday, 19 October 2026" is not named by "2026-10-29".
+            named_label = bool(label_words & goal_named) or bool(dates(info.get("label")))
             ok = (named_value and (named_label or not label_words or kind != "input")) if value_words else named_label
             if ok:
                 opening = False

package/py/forgeqe_engine/logins.py

@@ -111,6 +111,7 @@ def totp_code(secret: str) -> str:
 
 def prompt_block(logins: List[Login]) -> Optional[str]:
     lines = []
+    sessions = []
     for login in logins:
         parts = [
             f"{label} <secret>{login.placeholder(field)}</secret>"
@@ -119,17 +120,28 @@ def prompt_block(logins: List[Login]) -> Optional[str]:
         ]
         if parts:
             lines.append(f"- {login.name} on {', '.join(login.domains)}: {', '.join(parts)}")
-    if not lines:
+        elif login.session_file:
+            # A login with only a saved session (SSO, captcha): the browser starts signed in, and there is nothing to type.
+            # Without this line the agent was told "sign in with the saved login X" and typed X as the email address.
+            sessions.append(f"- {login.name} on {', '.join(login.domains)}")
+    if not lines and not sessions:
         return None
-    return "\n".join(
-        [
-            "## Saved logins",
+    out = ["## Saved logins"]
+    if lines:
+        out += [
             "Use these only when the site asks you to sign in (a login form, or a page asking for an authenticator / 2FA / one-time code) and the task did not give other credentials. "
             "Type the placeholder exactly as written, including the <secret> tags; the real value is filled in for you. "
             "The one-time code placeholder produces a fresh code each time you type it. If the page already shows you signed in, carry on without signing in again.",
             *lines,
         ]
-    )
+    if sessions:
+        out += [
+            "These logins are a saved browser session only: there is no username or password for them. "
+            "If one of these sites shows a sign-in page, do not type the login's name, an email address, or anything else into it: "
+            "stop and report that the site asked to sign in and the saved session for that login did not cover it, so it must be saved again with forgeqe login <name>.",
+            *sessions,
+        ]
+    return "\n".join(out)
 
 
 def _host_matches(host: str, login_hosts: List[str]) -> bool:

package/py/forgeqe_engine/loops.py

@@ -72,6 +72,17 @@ def resume_steps(steps: List[Dict[str, Any]], step_of: List[int], failed_at: int
 _LOOP_PRONE_ACTION_KEYS = frozenset({"input", "click", "search", "type", "select"})
 
 
+# Actions that only read the page, and the parameter that says what they read. The same read again finds the same
+# thing: the Booking.com log searched one page for the same price pattern six times in a row until the run timed out.
+_READ_ACTION_PARAMS = {
+    "search_page": "pattern",
+    "find_text": "text",
+    "find_elements": "selector",
+    "extract": "query",
+    "evaluate": "code",
+}
+
+
 _CONTROL_LOOP_GOAL_KEYWORDS = ("search", "select", "outlet", "autocomplete", "combobox", "filter", "lookup", "pick", "choose")
 
 
@@ -94,10 +105,13 @@ def _normalize_snippet(s: str) -> str:
 
 
 def _action_fingerprint(action_name: str, params: Any) -> Optional[str]:
-    if action_name not in _LOOP_PRONE_ACTION_KEYS:
-        return None
     if not isinstance(params, dict):
         params = {}
+    if action_name in _READ_ACTION_PARAMS:
+        what = _normalize_snippet(str(params.get(_READ_ACTION_PARAMS[action_name]) or ""))
+        return f"read|{action_name}|{what[:200]}"
+    if action_name not in _LOOP_PRONE_ACTION_KEYS:
+        return None
     if action_name in ("input", "type"):
         text = str(params.get("text", "")).strip().lower()
         return f"input|{params.get('index')}|{text}"
@@ -148,8 +162,15 @@ def _loop_start(collected_steps: List[Dict[str, Any]], fingerprint: str, window:
     return first, line
 
 
-def _loop_nudge_message(*, line: str, count: int, window: int) -> str:
+def _loop_nudge_message(*, line: str, count: int, window: int, fingerprint: str = "") -> str:
     what = f"`{line}`" if line else "the same action"
+    if fingerprint.startswith("read|"):
+        return (
+            f"ForgeQE: you have done {what} {count} times in the last {window} steps. Reading the page the same way again "
+            "finds the same thing. Use what the earlier reads found: if the page does not show what you are looking for, "
+            "it may show it another way (a total instead of a per-night price, a range instead of a value), so work from "
+            "what is there, or read another part of the page. If you have what the task asks for, call done now."
+        )
     return (
         f"ForgeQE: you have done {what} {count} times in the last {window} steps and the page is still not where you want it. "
         "Doing it again will not help. Before acting, look at the current page and work out why the earlier attempts did not stick: "
@@ -185,6 +206,8 @@ def _control_loop_break_message(*, count: int, max_retries: int, fingerprint: Op
             detail = f" (repeated input '{parts[2]}')" if len(parts) >= 3 and parts[2] else " (repeated input on the same field)"
         elif fingerprint.startswith("search|"):
             detail = " (repeated search)"
+        elif fingerprint.startswith("read|"):
+            detail = " (repeated the same read of the page)"
         elif fingerprint.startswith("select|"):
             detail = " (repeated select)"
         elif fingerprint.startswith("goal|"):