{"report":{"v":1,"package":"qiksy-mcp","version":"1.86.0","ranAt":"2026-11-16T11:40:46.603Z","install":{"ok":true,"integrity":"sha512-NQ6nFNzLabr3/58LDqKEKOPORIyIt4wJ9QTOXTOAHHKjVl6HO/+pRs8AEoLrfN6Md9QrNY05dW4viKikzVcrpQ==","deps":96,"scripts":[],"bins":["qiksy-mcp"],"license":"SEE LICENSE IN README.md","engines":"node >=18","bin":"qiksy-mcp"},"start":{"ok":true,"ms":357,"serverName":"qiksy","serverVersion":"1.86.0","protocol":"2025-06-18","stderr":"[qiksy-mcp] WARNING: QIKSY_MCP_TOKEN is not set. Set the same token here and in the Qiksy popup, or connections are refused.\n[qiksy-mcp] MCP stdio server ready\n[qiksy-mcp] bridge listening on ws://127.0.0.1:7333 — token MISSING\n"},"tools":[{"name":"qa_collect","description":"ASK FOR A TABLE INSTEAD OF A PAGE. Name WHICH nodes (a CSS selector, a role, a name fragment — any combination, scoped with `within`) and WHICH of their properties to take, and get back exactly that, once. «Every row in the list with its name and price», «every link in the nav and where it points», «all the inputs with what they currently hold» are one call here and a dozen with qa_snapshot plus qa_read. Take any of: text · value (what the control HOLDS, read the way the fill engine reads it) · name (accessible name) · role · tag · selector · href · state (disabled/required/invalid/expanded/checked/hidden) · geometry — plus attr:<name> for an attribute and style:<css-property> for a computed style. A property nobody can supply is named back rather than dropped, so a missing column is never mistaken for a missing feature. Read-only, and the vocabulary is closed: this is a different projection of the page, never a program the page runs.","params":["tabId","nodes","take","properties","limit","select","omit","frameId"]},{"name":"qa_steps","description":"WHAT THEY DID, NOT WHAT YOU DID. Every other verb here reports your own actions or the state of the page; this one hands over the tester's OWN work — each field with what they put in it, each click with whether it moved the page on, each navigation, in order, with timestamps. Reach for it when they say «write this up», «make a ticket out of that», «turn what I just did into a test», or when they describe a bug they found by hand and you need the steps that led to it. Guessing those steps from the page in front of you is the thing this removes: you were not there, and they will not remember the order. IT IS EMPTY UNLESS THEY ARE RECORDING, and that is the design rather than a limitation: the tape exists only while the person has recording switched on in the panel, with a mark on screen while it runs. An empty answer tells you how to ask them to start one. PASSWORDS AND CARD NUMBERS NEVER APPEAR — a redacted field is written down by NAME, with its value replaced by a reference, at the moment it is recorded. Reading, so it is free and needs no consent: nothing is touched, nothing is driven. AND IT DOES NOT GRADE THEM. You know what they were trying to do only if they told you; a judgement without that is a guess in a confident voice, which is worse than silence.","params":["tabId","limit","frameId"]},{"name":"qa_watch","description":"THE ONE QUESTION THE OTHER VERBS CANNOT ANSWER: what happens over the next few seconds. Everything else here answers about NOW — a toast that appears and leaves, a request fired by a timer, a row that arrives late, a value a websocket rewrites are all invisible to a snapshot taken before or after them. Polling costs a call per look and still misses the gaps between looks. op:\"start\" begins a watch and returns its id; op:\"read\" hands back what it has buffered since the last read; op:\"list\" shows what is running; op:\"stop\" ends one early (\"all\" ends every one). Four things can be watched: \"mutations\" (the DOM, optionally scoped with `within`), \"network\" (requests as they start and finish), \"console\" (console output, JS errors, rejections), \"announcements\" (aria-live regions — what a screen reader would have said). EVERY WATCH EXPIRES BY ITSELF — `ttlMs` is capped at two minutes and there is no \"until stopped\". That is deliberate: a watch left running is silent, and the readings taken after it are the ones that go wrong. It observes and never acts, so it needs no consent beyond the bridge itself.","params":["op","tabId","what","ttlMs","within","match","name","id","limit","drain","select","omit"]},{"name":"qa_diff","description":"PIXEL DIFFS SAY «23 417 PIXELS DIFFER» AND LEAVE YOU TO FIND OUT WHY. This one says «the Submit button moved 8px down, its padding went 8 → 12, and it went disabled» — a sentence with a cause in it. op:\"before\" takes the state of the page as it is now; do the thing (a fix, a deploy, a click, a different branch); op:\"after\" compares. Reported: what appeared, what disappeared, and what moved, resized, changed state or changed a style that people argue about. Text content is deliberately NOT compared — a name, a total or a timestamp differs between two healthy runs, and reporting those is exactly the noise that gets visual diffing switched off everywhere else. Movements under 2px are the browser rounding a layout. When the two states cannot be matched at all — a virtualised list, a re-keyed render — it SAYS so instead of reporting three hundred false appearances.","params":["tabId","op","draw","select","omit"]},{"name":"qa_open_tab","description":"OPEN AN ADDRESS THE BRIDGE WILL NOT NAVIGATE TO. The driving verbs stay inside the site under test on purpose — that refusal is what stops an agent from walking somebody's browser onto an arbitrary domain, and it must not be worked around. This is the sanctioned way through it: a NEW tab, beside the ones already open, losing nothing. It goes into the RIGHT BROWSER by construction, not by care: the machine has several Chrome profiles, the extension lives in exactly one, and a tab opened into any other is invisible here — so this finds the window holding a tab the bridge can already see and inserts the new one beside it. Never start a browser yourself instead; a second browser is a DIFFERENT, EMPTY browser with none of the person's logins, and everything measured in it stops being the run that was asked for. Read the answer rather than assuming: `inSession: true` means the tab is yours to drive and carries the tabId to pass to the other verbs; `inSession: false` means it is open and the person has to switch «Agent drives this tab» on for it, because once any tab has been switched on the session is that explicit set. macOS for now; elsewhere it says so and names what to ask for. Free.","params":["url"]},{"name":"qa_width_law","description":"THE LAW, NOT THE READING. «The container is 1360 wide» is a fact about the window it was measured in, true here and false one drag of the mouse later — which is why comparing a layout to a mockup by measuring has never worked. This reads what the CODE DECLARED instead: how many width ceilings exist on the layout spine, which element sets the tightest one, and what content band follows from that at any window. A declaration does not move when the window does, so it can be compared with a mockup and argued about. Pass `figmaWidth` (one number off the design, e.g. 1400) and it prints the two declarations side by side plus what follows — «the mockup declares one ceiling at 1400; the code declares none at all; at 1920 the band is 1840, which is 440 wider». It NEVER says which of the two is right: that is the human's call, and an instrument that guesses it is one nobody trusts twice. VALUES THAT MOVE WITH THE WINDOW ARE REFUSED ON PURPOSE. clamp(), vw and percentages declare no single law, so they go to a `notMeasured` list with the reason instead of being resolved at the current window and printed as if they were fixed — that number would be right on this screen and wrong on the next, and indistinguishable from a real finding. Narrow boxes (a sidebar, a card) are not judged either: they are narrow by design. Read-only and free. Read `notMeasured` FIRST — a clean page and an unexamined one look identical without it.","params":["tabId","within","figmaWidth"]},{"name":"qa_odd_one_out","description":"ONE OF THIRTY IS NOT LIKE THE OTHER TWENTY-NINE. No mockup, no Figma, no setup, no alignment: every element is compared ONLY with its own siblings, read in one instant, so nothing here depends on the window or on matching a design layer to a DOM node — the comparison the market cannot do is the one this skips entirely. It finds the card whose padding is 12 where twenty-nine have 16, the one gap of 14 in a row of 16s, the heading left at a different line-height. FOUR SILENCERS, and each exists because without it the verb produces findings on a HEALTHY page, which is how a checker teaches its reader to ignore it: a crowd of fewer than three is not judged; values with no dominant majority mean these are different elements rather than twins with a defect; more than two differing means a deliberate second variant; and an element the page itself marks as being in another state (`aria-current`, `aria-selected`, `disabled`, a class like `is-active`) is not comparable with its siblings on appearance. That last one came from a live run that reported the SELECTED TAB as a defect — twice. `margin` and `width` are deliberately not judged: the first and last member of a list legitimately carry a different margin, and content drives width. The SPACE between members is measured instead, which carries the same information without the trap. Read `notJudged` as well as `findings`: a family that was silenced is NOT a family that passed, and every silence names its reason. Read-only and free.","params":["tabId","within","selector"]},{"name":"qa_shot_list","description":"EVERY SHOT THE PANEL IS HOLDING, by name, with its size, its address, how many marks it carries and whether it is cropped. Taking a picture puts it on the shelf by itself, so this is also the answer to «what did the tester just capture». Names come from the path («checkout», «checkout-2»), because a person can hold those in their head and a timestamp they cannot. Read-only.","params":["tabId"]},{"name":"qa_shot_read","description":"THE MARKS, NOT THE PIXELS. Returns every mark on the named shot — kind, position, colour, caption — plus its crop rectangle and its true size. This is how you find out what a PERSON drew: they marked the broken total with an arrow and typed a word beside it, and that word is readable here rather than being an image somebody has to look at. It deliberately does NOT return the picture: a full-page shot is megabytes of base64 through a channel that copies every byte, and the question was what is on it. Use qa_screenshot when pixels are what you need.","params":["tabId","shot"]},{"name":"qa_shot_mark","description":"ADD MARKS TO A SHOT ON THE SHELF. They are stored beside the clean image, never burned into it, so the tester can move them, resize them and delete them afterwards — and so you can read them back later. Coordinates are in IMAGE pixels; qa_screenshot returns a map of the page in exactly those pixels, so a box from the map can be passed straight through. Shapes: `box` round a region, `arrow` from one point to another, `text` for a caption with its own words, `blur` for a pane that makes what is under it unreadable. Weight is `k`; colour is one of the five the panel offers. A caption carries an optional `to` — the point it is ABOUT — and a leader line is then drawn from the plate to that point, in both the editor and the exported file. Give a box a caption with `to` set to the middle of that box and you get the callout a person would draw by hand; the tester can then drag the words anywhere and the line follows. A `blur` pane hides an address, a customer name or a staging token. It is applied when the picture is EXPORTED, copied or built into a report — the clean shot stays clean on the shelf, which is what lets the pane be moved and removed afterwards. Adds by default; pass `replace: true` to put your marks in place of everything on the picture — which is the destructive one, and it is opt-in for that reason. The reply is the STATE — how many marks the picture now carries and all of them in full — rather than the word «done».","params":["tabId","shot","replace","marks"]},{"name":"qa_shot_crop","description":"SET OR CLEAR THE REGION a shot exports. The crop is a rectangle remembered beside the marks, NOT applied to the bitmap — so the edge can be pulled back out afterwards, by you or by the tester, and «a bit more on the left» never means «take the screenshot again». Pixels are image pixels, the same ones qa_screenshot maps and qa_shot_mark draws in. Pass no rectangle to go back to the whole picture. This is the difference between a screenshot of a page and evidence about one thing: a reader who is handed eight thousand pixels and told «it is visible here» cannot see it.","params":["tabId","shot","crop"]},{"name":"qa_shot_drop","description":"REMOVE ONE SHOT, with its marks and its stored image. The shelf holds twenty and drops the oldest by itself, so this is for the ones you know are finished with — a shelf full of half-remembered pictures is the state where nobody can find the one that mattered. The reply names what is left.","params":["tabId","shot"]},{"name":"qa_report_build","description":"A SELF-CONTAINED HTML REPORT, built by ENUMERATION. You pass an ordered list of blocks with plain text fields; every scrap of markup, styling, escaping and picture-embedding happens on our side. No template is accepted and none can be — a verb here names an element or a value from a closed list, never a program. IT IS NOT ONLY A BUG REPORT, and the block set is what makes that true. `finding` says something is wrong; `point` makes the same card with a tone of good · info · warn · bad and NO «expected» line, which is how a check that passed, a design note or a description of how a screen behaves gets written down; `section` gives a long document headings. A sign-off, a walkthrough for a developer, a page of observations for a designer and a defect list are the same paper here. Pictures come from the shelf BY NAME and are flattened on the way in: the marks and the crop have been data up to that moment precisely so they could still be changed. Print the result to get a PDF — the stylesheet is written for paper as well as for screen. PASS `save` TO KEEP IT IN THE EXTENSION: the panel’s Shots tab then lists it under Reports with Open and Save, and qa_reports / qa_report_get read it back by name later. Without it the document exists only in this reply and in whatever file you write. IT REFUSES, and the refusals are the point. No blocks, a block naming a shot that is not on the shelf, or NOT ONE PICTURE anywhere in the document — each fails the whole build rather than quietly dropping a block: a page of assertions about an application with nothing showing any of it is the artefact this product exists to replace. EXPECTED IS NEVER INVENTED. Leave `expected` out and the field says «not stated — a person fills this in». Filling it from your own guess turns a report into a hypothesis wearing the clothes of a protocol. The reply is an INVENTORY — blocks, pictures embedded, findings, points, bytes, warnings — not the word «done».","params":["tabId","out","save","kind","blocks"]},{"name":"qa_draft","description":"THE DRAFT REPORT AS IT STANDS: its title, what kind of document it is, and every line in order with its POSITION — which is what every other draft verb takes. It is the SAME draft the person is filling in the panel’s Report tab. A screenshot they flicked in this morning is here; a line you add appears on their screen. That is the whole point: a report written while the work happens, by both hands, instead of assembled from memory afterwards. Read-only, and free. Build it with qa_draft_build.","params":["tabId"]},{"name":"qa_draft_add","description":"ADD ONE LINE, OR SEVERAL, to the end of the draft — the same block shapes qa_report_build takes, so nothing has to be translated on the way out. The usual rhythm is one at a time, as things are noticed: a `finding` the moment it reproduces, a `shot` naming a picture from qa_shot_list, a `note` for the thing that is not a defect but matters. A picture is held BY NAME, never by pixels — so re-cropping or re-marking it later changes the report too. It answers with how many lines ACTUALLY went in: at the cap the draft keeps what fits, and saying «added 8» while 3 landed is how a document loses its middle.","params":["tabId","block","blocks"]},{"name":"qa_draft_edit","description":"REPLACE THE LINE AT `at` with a new block. The position comes from qa_draft. This is the verb for the wording — a finding whose title reads badly, an «expected» a person has now stated, a picture pointed at the right shot. Deleting and re-adding would put it at the END of the document, which is rarely where it belongs.","params":["tabId","at","block"]},{"name":"qa_draft_move","description":"MOVE THE LINE AT `at` TO `to`. Both are positions from qa_draft. A document usually needs this once, at the end, when the shape is clear.","params":["tabId","at","to"]},{"name":"qa_draft_drop","description":"REMOVE THE LINE AT `at`. The position comes from qa_draft, and the positions after it close up — read it again before dropping a second line.","params":["tabId","at"]},{"name":"qa_draft_meta","description":"SET THE TITLE, THE KIND, OR BOTH. The title becomes the document’s heading and the name the panel lists it under; leave it empty and the page title is used at build time. `kind` is what the document IS — issues (things that are wrong), verified (checked and it holds), notes (a description, no verdict). It changes no layout; the blocks do that.","params":["tabId","title","kind"]},{"name":"qa_draft_clear","description":"THROW THE DRAFT AWAY. There is no undo anywhere in this product, and the draft may be an hour of somebody else’s work — read qa_draft first and say what is in it before calling this. Building already empties it; this is for abandoning one.","params":["tabId"]},{"name":"qa_draft_build","description":"BUILD THE DRAFT into a self-contained HTML report — the same assembly qa_report_build does and the same one the panel’s Build button runs, so a document written by hand and one written here are the same document. It is KEPT in the extension by default, which is how the person finds it in the panel an hour later; `save: false` builds a preview and keeps nothing. THE DRAFT IS ONLY EMPTIED IF THE DOCUMENT WAS REALLY KEPT. When the browser has no room the HTML still comes back and the lines stay where they were — losing the work and the built document in the same breath is the one outcome this must never have. It refuses for the reasons qa_report_build refuses, and the important one is NO PICTURE: a page of assertions about an application showing none of them is the artefact this product exists to replace.","params":["tabId","out","name","save"]},{"name":"qa_report_edit","description":"EDIT A FINISHED DOCUMENT: read the blocks it was built from, change them, and build it again UNDER THE SAME NAME — so the shelf keeps one document rather than a family of near copies. This is the same operation the person does in the report editor. Call it with only a `name` to read the blocks back; pass `blocks` to replace them. The run’s own context — the address, the moment, the conditions the application was under — is carried over from the original and cannot be rewritten here, because those are facts about the run rather than about the wording. A report saved before its source was kept has nothing to edit, and says so.","params":["tabId","name","blocks","kind"]},{"name":"qa_reports","description":"EVERY SAVED REPORT, BY NAME, with its title, what kind it is, when it was built, how many blocks and pictures went in and how big it is. These are the documents `qa_report_build { save }` kept, and they are the same ones the person sees in the panel — so «open the checkout one» means the same thing on both sides. It deliberately does NOT return the HTML: a report with pictures inside is megabytes, and the question here is which ones exist. Use qa_report_get for one. Read-only.","params":["tabId"]},{"name":"qa_report_get","description":"THE DOCUMENT ITSELF, by the name qa_reports lists. Pass `out` to write it to a file — which is almost always what you want, because a self-contained report carries its pictures as data and spending that through this conversation buys nothing. Without `out` the HTML comes back inline. Read-only: it takes a copy and leaves the extension’s own untouched.","params":["tabId","name","out"]},{"name":"qa_report_drop","description":"REMOVES A SAVED REPORT FROM THE EXTENSION — the row and the document together, because an index that forgets an entry while the megabytes stay is a leak nobody finds. It touches nothing on the page and nothing on disk: a file you already wrote with `out` is yours and stays. The reply lists what is left.","params":["tabId","name"]},{"name":"qa_wiring","description":"A FORM WITH THREE RED MESSAGES UNDER THREE FIELDS LOOKS CORRECT TO EVERYONE WHO CAN SEE IT. That is the illusion: being NEAR a field is not being attached to it, and assistive technology reads the attachment. Somebody filling the form by ear is told «Email» and nothing else, while «Enter a valid email address» sits in red an inch below, invisible to them. Nobody can check this by looking, which is why it survives in shipped products for years. This reads the wire out of the tree — aria-errormessage, aria-describedby, label — and reports: which messages are attached to which fields, which messages are attached to NOTHING, and which fields are marked invalid with no reason given at all. Pass `draw` to get the picture: a line from every field to its message, and a stub on every message whose line ends in mid-air. It deliberately under-reports: a message inside its field's label, and an error summary that links to its fields, are both correct by another route and are not called orphans. A wrongly accused form costs somebody an afternoon proving the tool wrong.","params":["tabId","draw"]},{"name":"qa_focus_proof","description":"THE ARGUMENT NOBODY WINS WITH A SCREENSHOT, ended with two numbers. Focus the control and measure what actually changed: which of the four properties that can draw a ring moved (outline, box-shadow, border, colours), and what fraction of the PIXELS differ between the two frames. «Nothing in the styles changed and 0.0% of the pixels moved» is a sentence a developer cannot argue with; a screenshot of a missing ring looks exactly like a screenshot of a faint one. It is careful about the three ways this test lies elsewhere: the crop is widened by however far the styles say the ring can reach (an outline is drawn OUTSIDE the box, and a tight crop would swear it was absent), the second frame is taken after any transition has had time to finish, and a ring that is present but faint is reported as present — that is a contrast question, and this verb refuses to collapse the two. Read-only, and it puts focus back where it found it. Returns both frames, so the picture and the number travel together.","params":["tabId","selector","path"]},{"name":"qa_annotate","description":"A MARK THAT KNOWS WHAT IT POINTS AT. Name the element — a CSS selector — and the box is looked up from the page itself at capture time, so the same instruction draws the correct picture today, after a fix, and at another screen width. An arrow drawn on an ordinary screenshot points at a coordinate: right when it was drawn, wrong the moment anything re-renders. That is why annotated screenshots are disposable, and it is the whole difference here. It is also how a picture marks ITSELF: a finding already carries a selector, so «draw the contrast failures» needs no aiming — pass their selectors straight through. Shapes: `box` (outline it), `pin` (a numbered dot at its corner — for ordered things like a tab route), `arrow` and `line` (from one element to another, which is how you show an error message wired to the wrong field), and `blur` (a pane that makes the element unreadable — an address, a customer's name, a token in a staging header). Colours are named, not free: default · bad · good · info · warn. A LABEL IS A CALLOUT, not a sticker: it is placed in free space beside its element, clear of every other mark, and joined to the outline by a leader line ending in a dot. So «outline the payment block and say what is wrong with it» comes back as one readable statement instead of words stamped over the thing they are about. A mark whose element is not on the page is REPORTED in `missed`, never silently dropped — a reader who sees three arrows must be able to trust that there were three things to point at. Read-only: it photographs and draws, and touches nothing — a blur hides the data in THIS picture, never on the page, so the next capture shows it again.","params":["tabId","fromFindings","marks","path"]},{"name":"qa_failure_gallery","description":"THE PICTURES NOBODY EVER TAKES: the empty list, the 500 with the server's own words, the spinner that never resolves, the 403, the dropped connection. Every other capture tool can only photograph a failure that happens to occur — this one CAUSES it, because the response mocks and the camera are the same product. It walks the states one at a time: sets a rule, reloads, waits for the page, photographs it, removes the rule, moves on — and writes one self-contained HTML file with every picture embedded, which opens in any browser without this extension. That file is the point: the designer and the product owner who need to see the error states do not have Qiksy and never will. The rules are ALWAYS removed at the end, including when something throws — a rule left behind outlives the reason for it and makes the next measurement on the tab a lie. Scope is the mocks' own: the page's fetch/XHR in the top frame, so an app fed by a WebSocket will show a gallery of healthy screens and say so. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","url","states","path","full","maxWidth"]},{"name":"qa_gap","description":"SAY WHAT THE BRIDGE COULD NOT DO, IN ONE SENTENCE — and it becomes a line in a file the human reads (~/.qiksy/gaps.jsonl). This is the sanctioned way out of a dead end, and it exists because the usual way out is worse: an agent that hits a wall silently switches to another browser driver, and the run stops being the test that was asked for. Use it when the bridge genuinely lacks a capability — not when a control refused once (that is the ladder in the instructions: qa_probe, raw, a CSS selector, qa_click by name). op:\"list\" reads the log back, newest first, which is also how you check whether your gap is already known.","params":["op","wanted","verb","tried","url","blocked","limit"]},{"name":"qa_frames","description":"A PAGE IS OFTEN SEVERAL DOCUMENTS, AND THE INTERESTING ONE IS USUALLY NOT THE OUTER ONE. A payment form, an SSO step, a chat widget, a Stripe or 3-D Secure field: each lives in a frame of its own, and a frame from another domain cannot be read from the page around it — that is the same-origin rule and no amount of JavaScript gets past it. Qiksy now runs INSIDE every frame and answers about its own document, which is what makes them readable at all. This lists them: `frameId`, the address, the title, and how many controls each holds, with the page itself first. Pass the `frameId` you want to qa_read, qa_styles and the other reading verbs; leave it out and you get the page itself, never a frame picked at random. Call this the moment a control you can see on screen is missing from qa_snapshot: nine times out of ten it is not missing, it is in a frame nobody named. Read-only and free.","params":["tabId"]},{"name":"qa_tabs","description":"List the browser tabs Qiksy can read, including which are ISOLATED multi-login sessions (isolatedSession = the login name). Use a tab's tabId with the other tools to read that specific login. With two browsers or Chrome profiles connected at once, every tab also carries `browser` (1 = the one connected first) and the reply says `browsers`; pass the tabId and the call goes to the browser that holds that tab, while a call with no tabId goes to browser 1.","params":[]},{"name":"qa_status","description":"Health snapshot of a page Qiksy is watching: URL, error/warning/form counts, and its isolated-login name if any. Defaults to the active tab; pass tabId (from qa_tabs) to target a specific tab.","params":["tabId"]},{"name":"qa_findings","description":"Findings on a page (console/JS/network/a11y/markup/submit) — each with a CSS selector and detail. Filter by severity; pass tabId (from qa_tabs) to read a specific tab / isolated login.","params":["severity","tabId","select","omit"]},{"name":"qa_export","description":"Full qa-export/v1 bundle for a page: findings (with selectors), failed requests (with server error bodies), detected form structure, recorded repro steps, env, and isolated-login name. Read this, then fix the underlying issues. Pass tabId (from qa_tabs) to target a specific tab / isolated login.","params":["tabId","select","omit"]},{"name":"qa_open_panel","description":"Open (or close) the Qiksy side panel on a tab and optionally jump to a tab: 'forms' | 'findings' | 'tour' | 'tools' | 'history' | 'roles'. Controls Qiksy's OWN UI only — it does not touch the page under test. Set open:false to close.","params":["tabId","open","tab"]},{"name":"qa_run_audit","description":"Run Qiksy's a11y/markup audit on the current DOM (unlabeled controls, missing names, WCAG AA contrast, broken images, duplicate ids, positive tabindex, …) and return the findings. Also refreshes the panel. Static, non-destructive — reads the DOM only.","params":["tabId","select","omit"]},{"name":"qa_axe","description":"The industry-standard accessibility rule engine (axe-core — the one under Lighthouse), bundled INSIDE the extension and run locally on the live DOM: nothing leaves the page, no remote code. Hundreds of WCAG A/AA checks on top of qa_run_audit's own set, narrowed to WCAG-tagged rules so every violation maps to a criterion. Returns violations with impact, WCAG tags, help URL and up to 10 offending selectors each. Read-only. Needs an extension build that carries the engine — an older build answers \"unknown command: axe\" (reload the extension after updating).","params":["tabId","select","omit"]},{"name":"qa_read","description":"Return the RENDERED text of the page under test, or of a single element named by a qa_snapshot ref or a CSS selector. This is the companion to qa_snapshot: that one maps what you can ACT on (roles, names, refs) and caps every name at 80 characters, so anything longer — a one-time code in an email, an error paragraph, a generated invoice number — is invisible to it. Uses innerText, so hidden branches and a mail thread's collapsed quoted history stay out. Read-only: it executes nothing and returns text, capped (default 4000 chars, max 20000).","params":["tabId","ref","selector","maxChars","frameId"]},{"name":"qa_upload","description":"Put a file into an <input type=file> — including the hidden ones behind a styled dropzone, which a click can never reach. Three ways to choose what goes in: `fixture` for a hostile edge-case file (the upload counterpart of naughty strings — empty, oversize, wrong-type, corrupt, unicode name, unsanitised SVG…), `path` for a file on this machine, or `content` as base64. Pass `content` as base64 to attach a file YOU generated (a PDF fixture, a malformed CSV, an oversized image); omit it and Qiksy attaches a neutral test file matched to the field's `accept`. A content script has no filesystem access and the OS file picker is a modal an agent must never open, so bytes over this bridge are the only way a file from outside the browser gets in. AND WHERE THERE IS NO FILE INPUT AT ALL — a button that calls the native picker straight away, as YouTube Studio's audio-language dialog does — name that button with `field` and the file is handed to the picker it opens, exactly as a person choosing it would. The reply says `via` when that route was used, and it says so only when the page actually took the file. Delivery fires both paths uploaders use — assigning `input.files` + change, and a synthetic drop on the nearest dropzone — because react-dropzone-style components listen only for the second. SEVERAL FIELDS IN ONE CALL: pass `files` — an array of the same arguments — and they are attached in order, one round trip for the whole step instead of one per file.","params":["tabId","files","ref","selector","field","name","mimeType","fixture","path","content"]},{"name":"qa_storage","description":"Read and write the app's own localStorage / sessionStorage — flip a feature flag, expire a token to test the re-auth path, or prove what the app actually persisted after a save. Without `op` (or with op:'list'/'get') it READS and is free like every other read on this bridge; op:'set'|'remove'|'clear' WRITES and needs the Agent control consent, because changing a stored token or flag changes what the app does just as surely as clicking does. Closed vocabulary — it executes nothing you supply, it names a key. Listing truncates long values at 300 chars; ask for one key by name to get it whole.","params":["tabId","area","op","key","value"]},{"name":"qa_dialogs","description":"The browser's OWN dialogs — “Leave site? Changes you made may not be saved”, confirm(), alert(), prompt() — are drawn outside the document, so no click of any kind can reach their buttons. Nothing on this bridge can press them and nothing in any page can. What IS reachable is the page's REQUEST for them, and that is what this changes: `beforeunload:true` stops the app from asking, so the navigation simply proceeds; `confirm:\"accept\"|\"dismiss\"` decides what confirm() returns; `alert:true` swallows alerts; `prompt` supplies the string (or null to cancel). op:'list' is free and reads the policy in force; setting one needs the Agent control consent, because an auto-accepted confirm can be the one in front of Delete. SCOPE: this tab, until it closes; it survives reloads of it. EVERY suppressed dialog is logged as a finding carrying the question the page asked and the answer given — so never report that the app stopped asking. It asked; Qiksy answered. Clear it (op:'clear') as soon as the flow is through.","params":["tabId","op","beforeunload","confirm","alert","prompt"]},{"name":"qa_mock","description":"Override what the app RECEIVES from the network — the thing DevTools calls a local override, driven from here. Set a rule and the page's next matching fetch/XHR is answered by it: your status, your body, optionally after a delay, or as an outright network failure. This is how you test the paths a server will not produce on demand: an empty list, a 500, a 403 that should log the user out, a 30-second response that should show a spinner, a malformed payload, a field the API does not return yet. op:'list' is free and READS the rules in force; set / remove / toggle / clear change what the app sees and need the Agent control consent, because an app fed an invented 200 can persist it. MATCHING: `url` is a substring of the full URL, or `/regex/flags` when you wrap it in slashes; `method` defaults to any. First matching enabled rule wins. `times` spends the rule after N answers (leave it out for unlimited) — that is how you make the FIRST call fail and the retry succeed. LIFETIME: a rule belongs to ONE TAB, survives reloads of it, and is gone when it closes. It is not in force in any other tab. WHAT IT DOES NOT CATCH, so you do not debug a rule that was never consulted: only the page's own fetch/XHR in the top frame. Not the HTML document itself, not images/scripts/stylesheets, not WebSocket or EventSource, not sendBeacon, not requests made inside an iframe or from the page's own service worker. Mocked responses are logged as `(mocked)` in the session, the HAR and the report — a value you invented is never presented as the server's. Remember to clear rules when you are done; a forgotten mock is the most expensive thing here.","params":["tabId","op","id","url","method","status","body","headers","delayMs","fail","times","note","enabled"]},{"name":"qa_styles","description":"The COMPUTED styles of one element — colour, type, spacing, border, shadow, layout — plus its box in CSS pixels, and the CSS custom properties (design tokens) in scope for it. This is how you check a built page against a design: it answers \"this button renders #3B82F6 at 15px with 22px padding\" without a screenshot and without measuring anything by eye. Target it by a qa_snapshot ref (preferred) or a CSS selector. Read-only and executes NOTHING: the property list is fixed in the extension, so you name an element, never a program. Pair it with a design source (a Figma file, a token JSON) to report the diff, and with qa_spotlight to show the human which element you mean.","params":["tabId","ref","selector","tokens","frameId"]},{"name":"qa_snapshot","description":"A compact accessibility / interaction snapshot of the WHOLE page: every interactive control, landmark and heading with a role, an accessible name, its state, and a STABLE ref like [ref=e12]. Unlike qa_export — which lists only the FORM fields Qiksy detects and can miss inputs, file uploads, date pickers, selects and buttons — this \"sees everything\". Pass a ref straight back to qa_click / qa_type / qa_spotlight: a ref is unique and unambiguous, so it works where a CSS selector is duplicated across fields. Built in the live, already-authenticated page in ~milliseconds — no browser launch, no CDP. Re-run it after the page changes to refresh the refs. ONE SNAPSHOT OWNS ITS REFS: taking a new one RENUMBERS them, so every ref from an earlier snapshot is void even when its element is still on the page — e12 may now be a different control, and nothing will refuse the click. Keep only the refs of your latest snapshot; where you cannot, target by `name` (qa_click, qa_fill_json), which survives both a re-render and a renumbering. On a big app, NARROW IT: `fields_only` for the form controls, `roles` for exactly the kinds you want, `match` for a name, `within` for one dialog or step panel. Filtering happens on the way out and does NOT invalidate anything — the refs you get back work like any other. One step of a wizard usually needs `fields_only:true, roles:[\"button\"]`, not the whole page.","params":["tabId","geometry","fields_only","roles","match","within","limit","format","select","omit","frameId"]},{"name":"qa_tour","description":"Return a generated per-page exploratory-testing checklist (from detected forms + interactive surfaces), with items auto-checked from the recorded session. Great raw material for writing test cases. Returns markdown + structured items.","params":["tabId"]},{"name":"qa_report","description":"Generate Qiksy's self-contained HTML report — coverage stats, per-page table, steps with screenshots, findings — and return the HTML. Pass `spec` to make it answer the question the TICKET asked: give it the story and your verdict on each acceptance criterion, and the report leads with those, rendered next to the evidence Qiksy collected itself (errors, failed requests with server bodies, screenshots). That turns a log into a deliverable a developer or a client can read. You supply the verdicts — you are the one who read the story; Qiksy supplies the proof. Requires History recording to have captured steps; otherwise returns a note.","params":["tabId","path","spec"]},{"name":"qa_spotlight","description":"Visually highlight (dim + outline) an element on the page — target it by a qa_snapshot ref (preferred) or a CSS selector — so the human tester can see what the agent is referring to. A non-destructive overlay — it does not click, focus, or modify the element.","params":["tabId","selector","ref","label"]},{"name":"qa_click_point","description":"Click at an x,y POINT instead of at an element — for applications that draw their interface inside a canvas, where there is nothing to name: Figma, Miro, maps, charts, diagram and image editors. Everywhere else use qa_click: it names what it pressed, survives a re-render and tells you when it missed, none of which a coordinate can do. Coordinates are CSS pixels from the top-left of the VIEWPORT, not of the page — the same frame a qa_screenshot is taken in, so reading a position off a screenshot works; scroll the target into view first. The reply names the element the browser found under the point, and carries the usual `changed` diff, so you can tell a press that did something from one that landed on empty canvas. HONEST LIMIT, and it is not theoretical: these events carry `isTrusted: false`. Anything that checks it will ignore the click and say nothing — measured on npmjs, where a React checkbox took the synthetic click and reverted it on the next render while a real one held. Canvas applications do not check it, which is why this verb is for them. When a page does check it, the reply carries `realMouse`: how to press the same point with a real click from the operating system (cliclick on macOS, PowerShell or AutoHotkey on Windows, xdotool on Linux) and how to turn this point into a screen one. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","x","y"]},{"name":"qa_drag_point","description":"Press at one point, move, release at another — the other half of canvas work, and the half a click cannot express: moving a shape, marqueeing a selection, panning, drawing a box, dragging a handle. Without it an agent fakes a drag out of two clicks and changes something nobody asked for. The pointer is moved in STEPS between the two points (12 by default), because a single jump from start to end is not a drag to most canvas code — it tracks the pointer while the button is down, and one giant delta reads as a glitch or as nothing at all. The moves go to the element the drag STARTED on, which is what a browser does once a button is down. Same coordinates and the same honest limit as qa_click_point: CSS pixels from the top-left of the viewport, and `isTrusted: false`. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","x","y","toX","toY","steps"]},{"name":"qa_hover","description":"Put the pointer on an element AND LEAVE IT THERE, then report what that revealed: a menu that opens on hover, a tooltip, the actions a row only shows under the pointer, the value a chart reads out beneath it. qa_click cannot answer any of those — it presses a millisecond after it hovers, and the press closes what the hover opened. It holds for `holdMs` (500 by default) before measuring, because tooltips wait — measuring at once reports \"no tooltip\" about one that was always going to appear. The reply carries the usual `changed` diff plus `tooltip` (role=tooltip, aria-describedby or title, whichever exists) and `expanded` when the control changed its aria-expanded. ONE FACT TO READ CAREFULLY: `cssHover` says whether the browser's own `:hover` matched. Dispatched events run the page's JavaScript handlers — every menu and tooltip library — but they do not move the real cursor, so an effect written PURELY in CSS does not appear and `cssHover` comes back false. That is the tool being honest, not the page being broken. With trusted input switched on the real pointer moves, `cssHover` is true, and CSS-only hovers light up too. Call it again with `off: true` to take the pointer away — \"the tooltip disappears\" is the other half of the check, and it needs its own call. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","selector","ref","x","y","holdMs","off"]},{"name":"qa_click","description":"Click an element on the page under test — by a qa_snapshot ref, by a CSS selector, or by the control's accessible `name` (the one to use right after a fill, since filling re-renders the step and staleness is what makes a ref refuse). Sends the full pointer sequence (pointerdown → mouseup → click), so component libraries that listen for pointerdown — Radix, shadcn, MUI — react to it like a real click. Scrolls the element into view first, and refuses a target that matches nothing or has zero size rather than silently doing nothing. Returns what the click CHANGED — what appeared, disappeared or updated once the page settled — so you do not need a follow-up qa_snapshot to find out whether it did anything. `changed: null` means the page did not move, which is itself the answer. On a recent extension build the reply also carries `announced` — what the page's live regions (aria-live / role=status / role=alert) actually spoke during the settle window, or null if they stayed silent: a toast that appeared in `changed` but not in `announced` is invisible to a screen reader (WCAG 4.1.3). AND WHEN THE PRESS NAVIGATED there is no diff to give: the reply carries `navigated: <the new url>` instead. That IS what the press did — do not press again, a second one would land on the NEXT page rather than repeat this one. BEFORE READING AN EMPTY DIFF AS A DEAD CONTROL, look for `tab` in the reply: it is there only when this tab was not in front, and `state: \"hidden\"` means Chrome had stopped painting it, so a popover could not render and nothing on an animation frame ran. Call qa_focus_tab and click again rather than filing anything. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","selector","ref","name","role","frameId"]},{"name":"qa_type","description":"Put a value into ONE control, whatever kind it is — target it by a qa_snapshot ref (preferred) or a CSS selector. This is not a keystroke emulator, it is the extension's own fill engine, the same one behind the ⚡Fill button, so \"typing\" works on far more than text boxes: text/number/date inputs and textareas (native value setter + InputEvent, so React/Vue controlled inputs keep the value), native <select> (your text is matched against the option labels), checkboxes and radios (a truthy value checks it, with a real click so the app's listeners run), CUSTOM SELECTS and typeahead comboboxes (Radix/shadcn, MUI, Ant, react-select, Downshift — it opens the popover, waits for the options, picks the one matching your value and verifies the trigger actually changed), POPUP DATE & TIME PICKERS (opens the calendar and picks a day), sliders, and contenteditable rich text. A file field takes the neutral Qiksy test file matched to its `accept` — use qa_upload when the bytes matter. So do NOT click a dropdown open, snapshot to read its options and click one: name the field and the value you want. Only fall back to the click path when this answers ok:false. Reports back whether the value stuck, so a masked or read-only field is visible to you rather than silently ignored. WHAT `stuck: true` DOES NOT PROMISE: it says the DOM kept the value, not that the app took it. When the tab is not in front the reply therefore also carries `tab` — `state: \"hidden\"` (another tab is active, so Chrome is not painting it and a popover will not render) or `state: \"unfocused\"` (the window is behind another application, so anything that commits on real focus or blur never gets it). It is a caveat and not a refusal: the fill still happened. If the answer matters, call qa_focus_tab and do it again. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","selector","ref","name","value","text","raw","commit","blur","open","pick","pickMs","settleMs","frameId"]},{"name":"qa_type_many","description":"Fill an ENTIRE form (or one step of a wizard) in ONE call instead of a round-trip per field: pass an array of { ref | selector, value, action? }. EVERY control kind qa_type drives goes in the same batch — custom selects and typeahead comboboxes (Radix/shadcn, MUI, Ant, react-select), popup date & time pickers, native selects, checkboxes, radios, sliders, rich text, plain inputs. A batch of ten fields where six are dropdowns and dates is the NORMAL use of this tool, not an edge case, and it is the difference between one call and thirty. They are filled in order and strictly one at a time (two open popovers break each other), so a step with several custom widgets still takes a few seconds of real waiting — that part is the widgets, not the round trip. PREFER `ref` from qa_snapshot: a form built from a repeated component gives several inputs the identical cssPath, and a batch of selectors would then pour every value into the first match. Returns a per-field result list plus filled/total; a field that came back ok:false is the only one worth a follow-up call. File fields are the one thing that belongs elsewhere — qa_upload takes files[] and attaches several in one round trip. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","fields"]},{"name":"qa_press","description":"Dispatch a keyboard key (keydown/keypress/keyup) — Enter to submit, Escape to close, Tab to move focus. Without a selector it goes to whatever currently has focus, like a real keyboard. Like qa_click, it returns what changed once the page settled. On a recent extension build the reply also carries `focus` — the element that ACTUALLY holds focus after the key (name, role, selector, box), which is how you follow a Tab route or catch focus landing somewhere unnamed — and `announced`, what the live regions spoke (null = they stayed silent). Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","key","selector","ref","frameId"]},{"name":"qa_wait_ready","description":"Block until the tab has finished loading AND Qiksy is live in the new document. Call this after anything that navigates — a submit, a link click, qa_navigate — before the next qa_type/qa_click, or the call lands on a page that is still being replaced. Read-only: waiting is not acting, so this needs no Pro and no consent.","params":["tabId","timeoutMs"]},{"name":"qa_wait_for","description":"Wait until the page satisfies ONE named condition, then return — instead of polling qa_snapshot, which renumbers every ref each time it is called. Conditions: `appears` / `disappears` / `enabled` (each takes an accessible name OR a CSS selector) · `text` / `textGone` (anywhere on the page) · `countOf` a selector with `atLeast` or `exactly` · `announced` (what the page said through a live region — pass a string to wait for one containing it, or true for any) · `urlContains`. Use it after anything whose answer arrives later than a click settles: an order confirmation, a slow save, a list that repopulates, a button that ungreys when validation finishes. A condition already true when you call returns immediately. ON TIMEOUT IT SAYS WHAT IT SAW — how many matched, how many were visible, the nearest names on the page, and anything announced — so a wait that failed on a typo tells you so instead of just running out. A SIGN-IN IS WHAT THIS IS FOR, MORE THAN ANYTHING ELSE. When the site hands over to a password, a code from a phone or a hardware key, that step is the person's — do not drive it and do not call it a failure. Tell them to sign in, then `qa_wait_for { urlContains: \"<the site you came from>\", timeoutMs: 180000 }`: it is answered by the extension, so it survives the navigation, and if the tab never moves at all it says THAT instead of just running out. Up to 300000 ms is real: the wait runs in slices and keeps the call alive. If it still comes back with `stillWaiting`, call it again with the same arguments; never ask the person to write that they are done. Read-only: waiting is not acting, so this needs no consent — the same footing as qa_wait_ready. There is no \"until quiet\" (that is what every action already does) and no \"until the network is idle\" (the interceptor sees only the page's own fetch/XHR in the top frame, so the number would not mean what its name says).","params":["tabId","appears","disappears","enabled","text","textGone","countOf","atLeast","exactly","announced","urlContains","timeoutMs"]},{"name":"qa_follow","description":"Turn this on at the START of anything with several steps — a sign-up, a wizard, creating an app in a developer console, a checkout. From then on every click, key, fill, type, upload and navigation on that tab answers with the STEP IT LED TO: the page is waited for until it stops loading, and the reply carries `step` — where the wizard is (`progress`), what changed since the last step (`changes`: a button became active, an error appeared, a new heading), the fields still to fill, the live buttons, and `yourMove`. No qa_snapshot, qa_read or qa_wait_ready between steps: the reply to the press IS the next step, so keep going instead of stopping to report after each one. WHEN THE STEP IS THE PERSON'S — a password, a code from their phone or mail, a captcha — the step says `personNeeded`. Tell them in one line, then call `qa_follow { waitForPerson: \"<that line, in their language>\" }` in the same turn: the line is shown on the page beside the field, and the call returns by itself the moment the page moves on (up to 15 minutes; `stillWaiting` means call it again — never ask them to write that they are done). It stays on until qa_done or `off: true`; a new qa_follow with another goal replaces it. Reading only: following needs no consent, the acting verbs keep their own gate.","params":["tabId","goal","waitForPerson","timeoutMs","off"]},{"name":"qa_help","description":"The full manual of this bridge: every verb, the ladder for a control that refuses a value, forms in one call, the fast `raw` route, widget verdicts, recipes and suites, mocks, native dialogs, isolated logins, reports, tabs and sign-in. The instructions you received at connect are the short version, and some clients cut even those. Call this when you are not sure which verb fits, or before a long form-heavy or multi-login task. Pass `topic` (a word such as \"form\", \"recipe\", \"mock\", \"dialog\", \"sign\", \"tab\", \"widget\", \"screenshot\") to get only the paragraphs that mention it. Free and read-only.","params":["topic"]},{"name":"qa_screenshot","description":"Take a real picture of the page under test, or of ONE element, and hand it back as an image you can look at — not as measurements. Use it for the questions geometry cannot answer: does this look right, is the shadow there, is the text legible on that background, what does the tester actually see. Pass `ref` or `selector` to crop to one element (with a little padding); omit both for the visible page. Pass `full: true` for THE WHOLE PAGE top to bottom, however long it is — the page is scrolled, photographed a screenful at a time and stitched into one picture, with a sticky header kept once rather than printed down the side. That is usually what a human means by \"show me the page\", and the visible-area shot answers a different question. It takes a second or so per screenful and cannot be combined with `ref`/`selector`. The Qiksy panel is hidden and password and card fields are covered BEFORE the frame is taken, so a screenshot pasted into a ticket carries no secret. THE TAB MUST BE IN FRONT: the browser photographs the window's active tab, and Qiksy refuses to photograph a different one rather than hand you a page you did not ask about — call qa_focus_tab first if you have been driving a background tab. A PICTURE OF THE PAGE IS NOT A PICTURE OF THE PERSON'S SCREEN: when Chrome is not the application in front, the reply carries `seenByHuman: false` and `screen`, and then the person is looking at something else. Say so; do not present the picture as what they see. EVERY SHOT CARRIES TWO THINGS A PICTURE CANNOT SAY ABOUT ITSELF: `build` — which build was actually running (the script files the page fetched, whatever version it declares, viewport, DPR, colour scheme, language), so nobody has to ask «which build was this»; and `receipt` — what was covered before the frame and what was never collected at all, which is what makes a picture of somebody else's application sendable. Downscaled to `maxWidth` (default 1200) because a retina frame is megabytes of context for pixels nobody needed. PASS `path` FOR A LONG PAGE: the file is written at FULL resolution — the downscale exists to protect this conversation, and a file is not this conversation. An inline thirty-screen shot is unreadable by arithmetic, not by accident. Read-only: it changes nothing on the page.","params":["tabId","ref","selector","full","maxWidth","path","searchable","map"]},{"name":"qa_navigate","description":"Point a tab at a URL and wait until it is loaded and Qiksy is live again — the ready-wait is built in, so the next step can run straight after. Use it to jump between steps of a flow that are not reachable by clicking. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","url"]},{"name":"qa_reload","description":"Reload the tab as it stands — same address, no URL to pass — and wait until it has loaded AND Qiksy is live in the new document, so the next call needs no sleep. Use it after anything a fresh load fixes: the extension updated under an open tab, a mock was cleared, storage was written by hand, the app wedged. The browser performs it, not the page's own script, so it works even when that script is already dead — which is exactly the case a reload is for. Pass bypassCache for the hard reload (Ctrl/Cmd+Shift+R) when you suspect a stale bundle. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","bypassCache"]},{"name":"qa_open_isolated","description":"Open a tab with its OWN private session — separate cookies, localStorage, IndexedDB — so a second (or third) user can be logged in at the same time in the same browser. Returns its `tabId`; pass that to any tool to run the whole flow as that user, while the first login keeps working untouched. This is how you test a hand-off: submit as one role here, then verify it as another role there, side by side. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["url","session","sessions","count"]},{"name":"qa_focus_tab","description":"Put a tab in front of the person — activate it and raise its window — so they are looking at what you are about to show. This is the WALKTHROUGH verb, and it is the one thing Qiksy otherwise refuses to do: everything else works in whatever tab is already in front, which is why a demo asked for from an editor used to land in a tab nobody was watching. Use it when you have been asked to SHOW, not to test — then narrate with qa_spotlight (its `label` is what turns a sequence of clicks into \"step 3 of 6\"). Do NOT call it to make your own work easier: taking someone's screen mid-sentence is the behaviour this product exists to avoid. Scoped to the app under test and its isolated logins (see qa_tabs) — it cannot reach the rest of the browser. Free: it neither reads nor changes the app. READ `raised` BEFORE YOU SAY «LOOK»: it is what the page itself reports, not what Chrome assumes. `raised: false` with `why: \"other-app\"` means Chrome is behind another application (an editor, this chat), which no extension can fix; `why: \"covered\"` means the tab's window is minimised or covered. Either way the person is NOT looking at the page: ask them in one line to click the browser (its dock icon bounces), and never describe a picture of the page as what they see.","params":["tabId"]},{"name":"qa_done","description":"CALL THIS WHEN THE WORK IS ACTUALLY OVER — the last check made, the last fix verified, the answer about to be written. The mark on every driven tab the person is NOT looking at then pulses slowly, so somebody who walked away from the screen can see from across the room that it ended. It stops by itself when they look at that tab; there is nothing to dismiss. It is a nudge, not a report: still say what you did, in your own words. And it is not a progress beat — calling it between steps teaches people to ignore it, which costs the signal its only job. Any further call cancels it, so a run that continues quietly withdraws it. A short sound plays as well, for somebody who is not looking at the browser at all — the person can switch the sound off in the popup, and the pulse stays either way. Free, and it touches nothing on the page.","params":["tabId","verdict"]},{"name":"qa_close_tab","description":"Close one tab or a list of them — how you tidy up the isolated logins when a matrix run is finished. Returns which ids closed and which were already gone. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","tabIds"]},{"name":"qa_fill_json","description":"Hand the page a plain JSON object — { \"Field label\": \"value\" } — and it fills the form in ONE call. No refs, no snapshot of your own: this takes its own snapshot, matches each key against the fields' accessible names (exact, then truncated, then contains) and passes the whole lot to the batch filler, so every control kind is covered — text, native and CUSTOM selects, typeahead comboboxes, date pickers, checkboxes (true/false), radios, sliders, rich text. This is the shape of the JSON behind the panel's own `{ }` editor and its ⚡Fill button, so a dataset you write here reads the same way a human would edit it. Reach for this when you ALREADY know the data — from a ticket, a persona, a CSV row — and for a form you have not mapped: it is one call instead of snapshot-then-batch. Use qa_snapshot + qa_type_many instead when you need to choose targets deliberately (duplicate labels, one specific control among many). Keys that match nothing come back as `unmatched`, together with the field names the page actually has, so the next call can use the right key without another round trip. DATE FIELDS BUILT FROM SECTIONS (MUI X DateField/DatePicker: separate Day / Month / Year spans the component owns) cannot be written to at all — the answer will say so under `verified`, and the way in is the calendar: click the \"Choose …\" button, switch to the year view, pick the year, step the month, click the day. A value of \"click\" PRESSES the thing instead of filling it — for the parts of a step that take no value: a chip, a custom radio (div role=radio), a switch, a toggle button. { \"Climate\": \"click\", \"Medium\": \"click\" } goes in the same batch as the text fields. REPEATED LABELS: a form built from a repeated component gives several controls the identical label — address them as \"Full name\", \"Full name#2\", \"Full name#3\", which is the same #N notation the panel's own dataset uses, so a dataset copied out of the `{ }` editor works as written. ONE CALL PER WIZARD STEP: pass `advance: \"Next\"` and this presses that control after the fill — but only when the fill was clean. It is NOT pressed if an entry came back ok:false, if a key matched nothing, or if a value is still wrong after the repair, and the reply says which of those it was. Whether the page really advanced is decided by the DIFF the click produced (a step swap makes many nodes appear AND disappear), never by the click answering ok: a Next that is disabled until the step validates accepts a click and does nothing — that case is caught before the click, from the control's own state, and comes back as `advanced.ok:false` with `stillNeeded`. When it did advance, `next` carries the FIELD NAMES of the step you are now on, so the following step costs no qa_snapshot of your own; pass next:false to leave them out. dry_run:true resolves the keys and fills nothing — read-only, and the cheap way to check a dataset against a page (with `advance` set it reports `wouldAdvance` and presses nothing). Requires the one-time “Agent c","params":["tabId","fields","within","dry_run","verify","advance","next","frameId"]},{"name":"qa_pick_date","description":"Put an EXACT date into a date field in ONE call — including the ones a value cannot be written to. It tries the cheap way first (type the date, press Enter, check it stuck), and only if that fails does it open the picker and steer it: the year view for MUI X, the clickable year in the header for Ant Design, the month/year dropdowns for react-datepicker, and plain arrows for anything else — stepping until the calendar header agrees, then clicking the day. Use this instead of writing to a date field whose value never sticks: MUI X DateField is three contenteditable sections the component rebuilds from its own state, so a written \"14\" can land in the YEAR and the day stay empty. Returns `via` (typed or calendar) and a `trail` of what it actually had to do, so a picker this does not recognise is visible rather than silent. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","date","open_label"]},{"name":"qa_pick_path","description":"One call for the widgets where a single value takes several interactions: an Ant Design Cascader (country → region → city, a column per level), a TreeSelect with collapsed branches, a menu of submenus, any drill-down. Pass the path as it reads on screen and it opens the control, clicks each level on a FRESH snapshot (opening a level is exactly what re-renders the popup), expands a branch that hides its children, and closes up afterwards. A level that never appears is reported with the levels that did, so you can see where the path diverged from the page instead of guessing. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","path","paths","multi"]},{"name":"qa_pick_tags","description":"One call for a whole list of tags on a control that has no option list to pick from — Ant Design's Select in `mode=\"tags\"`, and every chips input built the same way: the value is typed and committed with a key. Per tag it types, VERIFIES the text is still in the field, then presses the key, on a ref re-resolved each time. The verification is the point and it is not defensive coding: when a tag commits, the component clears its own search input, the re-render can wipe a value written a moment earlier, and the key then re-submits the PREVIOUS text — which in tags mode toggles that tag back OFF. That is how a form ends up with the tag you added first missing. It also never clicks the field first: a click moves the caret out of the component's search input and the text goes nowhere. Returns which tags went in and, for any that did not, what the field was holding instead. If a control refuses every tag it is probably NOT in tags mode — it only accepts values from its list, and qa_type with the option text is the right verb. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","tags","commit_key"]},{"name":"qa_pick_time","description":"A time in one call on a column-based picker — Ant Design's TimePicker and its equivalents. Needed because the cells are bare list items with NO accessibility role, so the snapshot cannot see them, and the ordinary fill path misreads the control as a date field (\"calendar did not open — typed an ISO date instead\") and leaves it empty while reporting success. This reads each column's text, finds which entry is your value and clicks THAT child, then presses the panel's own OK — which is not optional: without it the value stays provisional and the field ends up empty. Reading the column instead of computing an index is deliberate: the minute step is configurable and guessing it would be a bug. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","time"]},{"name":"qa_pick_range","description":"Both ends of a date range in one call, for a control that owns two inputs — Ant Design's RangePicker and its equivalents. Not the same as two qa_pick_date calls: the control walks from the start panel to the end panel by itself, and approaching it a second time from cold restarts the range on the start input, which is how a range ends up half-set. The start goes in through the normal single-date route (so every library it knows still applies), then the panel — still open — is steered to the end date by the same recipe with the opening click dropped. Reports a `trail` of what it clicked, and if the panel closed after the start it says so instead of pretending: some pickers do, and then the end date is its own field (\"End date\") for a plain qa_pick_date. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","from","to"]},{"name":"qa_focus_walk","description":"The keyboard route as ONE call: presses Tab repeatedly and records where focus actually lands, then compares that trail against the interactive elements the accessibility tree claims. This is the accessibility question a click can never answer — Qiksy clicks teleport to an element, a keyboard user has to REACH it. Reports: the focus trail; interactive elements that never got focus (the div-button a Tab user can never reach); a suspected focus TRAP when the same short cycle of names repeats without the walk closing; and order-vs-geometry suspects — consecutive stops where focus jumps far UP the page, the classic broken tab order. Honest limits, stated because this tool feeds audits: matching is by accessible NAME (the press reply carries no ref), so duplicate names can mask a missed element; focus VISIBILITY is not judged here (that is qa_styles on a stop that interests you); and the walk changes the page's focus for real, so run it before filling, not mid-form. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","maxSteps","sheet"]},{"name":"qa_probe","description":"Identify ONE unfamiliar control and get back the verb that drives it. Judges it first by shape — role, tag, name, state and its neighbours — which settles a sectioned date field, a file input, a switch, a slider or a plain field without touching the page at all. When the shape says nothing, which is what happens to a widget hand-rolled from <div>s (role \"generic\", no name, no state), it clicks once and reads what the page DID: day numbers or a grid appeared → a calendar, two options → a select however it is built, checkboxes → a tree, a menu, a modal, or the most useful verdict of the set — it went `expanded` and the tree gained NOTHING, which means the popup is portalled markup with no roles and must be addressed by CSS selector (Ant Design). Then it presses Escape so the form is left as it was found. Use it on the ONE field that just refused a value, not on every field: a snapshot already classifies the whole page (`componentLibraries` + `hints`), and driving is what the other verbs are for. Do not aim it at a Submit or Next — that click advances the page and Escape cannot take it back; the reply says `pageMoved` when it happened. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","selector","ref","close"]},{"name":"qa_recipe_save","description":"Write what you just did on this page to a JSON recipe on this machine, so the NEXT run replays it instead of rediscovering it. Call it with just a name and it builds the recipe from what this session actually filled: the fields (by accessible name, with the cssPath as fallback), the uploads, and the control you clicked to move on — folded into steps, since a click after a group of fills is what ends a step of a wizard. Pass `steps` yourself to write a recipe by hand, or to correct one. Do this at the END of any flow that took more than a few calls — a long multi-step form, a signup, a wizard — and say so in one line to the human: the recipe is a file they own, at the path this returns, editable and deletable by hand. Local only: writes a file, touches no browser, needs no consent.","params":["name","project","tags","url","notes","steps"]},{"name":"qa_recipe_list","description":"The flows already saved on this machine, newest first: name, host, step count, and the fields of the first step so you can tell them apart. Worth ONE call at the start of any form-heavy task — if a recipe for this host exists, replaying it beats rediscovering the form. Local only, no browser, no consent.","params":["url","project","tag"]},{"name":"qa_recipe_apply","description":"Replay a saved flow on the page as it is NOW. Per step it takes its own snapshot, matches every field by accessible name (exact, then truncated, then contains, then the stored cssPath), fills the whole step in ONE batch, attaches the step's uploads, and clicks the advance control — so a step costs you one call instead of a snapshot plus a call per field. Refs are never reused across runs; the names are. A field the page no longer has comes back under `missing` instead of failing the step, so you can see what drifted and fix that one field by hand. Override any value with `values` — same recipe, different data (that is how one saved flow becomes a data-driven test). START WITH dry_run:true: it resolves everything and changes nothing, needs no consent at all, and tells you whether the recipe still fits. IT ACTS: with `all` it walks every remaining step and clicks each advance control, so if the last step's advance is Submit, it submits. On anything irreversible, run the steps one at a time. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","step","all","values","dry_run"]},{"name":"qa_suite_run","description":"Replay a GROUP of saved flows back to back and answer about the whole set: which passed, which stopped, at what step and on what. Pick the set one of three ways — `recipes` by name, `project` (everything filed under that product or client), or `tag` ([\"smoke\"]). BOTH STORES ARE IN THE SET: the flows you saved here and the ones the human recorded in the panel's Scenarios tab (qa_scenarios), so a hand-recorded flow can be part of a project run. A name held by both is run from the panel — that is the copy the person edits. Each recipe is opened at its own start URL first, so recipe two does not begin on recipe one's confirmation screen. It does NOT stop at the first failure — a set is only useful when you learn the state of all of it — but each recipe still stops at its own first unresolved step, because filling on through a broken flow is worse than a short report. START WITH dry_run:true: it resolves every step of every recipe, changes nothing, and needs no consent at all. That is the honest way to ask \"do these still fit\" before running them for real. IT ACTS: a suite multiplies what one recipe does, submits included. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","recipes","project","tag","values","dry_run"]},{"name":"qa_scenarios","description":"The flows the human recorded in Qiksy's Scenarios tab, on this machine: name, project, tags, step and field counts, and — the part you need — the PLACEHOLDERS each one asks for. A scenario stores its route, not its content: a bug report or a task keeps the same fields every time and different text, so the values are named holes ({summary}, {steps}) that you fill per run. Worth one call before any long form on a host the human works on. Free, no consent, no browser action.","params":["tabId","host","project"]},{"name":"qa_scenario_get","description":"Everything about one recorded flow: its steps, every field with the value or placeholder it holds, and the flat label-to-value object the panel edits. Read this before running one you did not record — it is how you find out which placeholders exist and what a field is called.","params":["tabId","name"]},{"name":"qa_scenario_save","description":"Turn what you just drove into a scenario in Qiksy's Scenarios tab — the same list the human records into by hand, on the same machine. Call it with a name and it builds the flow from what this session actually filled: fields by accessible name, uploads, and the control you clicked to move on, folded into steps. Pass `steps` to write or correct one by hand. THIS IS THE ONE THE HUMAN CAN PRESS. qa_recipe_save writes a file for you to replay; this puts it in front of the person, with Run, Data and Random beside it, and it can be part of a project suite. Do it at the end of any flow that took more than a few calls, and tell them in one line that it is there — a scenario nobody knows about is one nobody runs. Stores data and touches no page, so it needs no Agent-control consent and no licence — scenarios are free, like everything else.","params":["tabId","name","from_page","project","tags","url","notes","steps"]},{"name":"qa_scenario_run","description":"Replay a flow recorded in the panel, on the page as it is now, with YOUR data. Give `vars` for its placeholders ({ \"summary\": \"Login 500s\" }) and/or `values` to override any field by its label. This is how a form somebody fills weekly — a bug in Jira, a task, a story — becomes one call: the route was recorded once by a human who knows the form, and you supply the text. Each step is filled through the same engine as the panel's Fill, and the run STOPS at the first field the page no longer has rather than filling on and pressing Next over an invalid form. Requires the one-time “Agent control” confirmation in the panel; without it the extension answers consent-required and does nothing.","params":["tabId","name","vars","values"]}],"toolsHash":"655a4cfc1155ee5ee86123069813ef7249d73ce0db1d5cfe3c41562356e3c35a","wrote":[],"callsAt":"2026-11-16T11:40:53.547Z","calls":[{"tool":"qa_shot_list","ok":false,"ms":6,"bytes":0,"error":"tool reported an error: Qiksy extension is not connected. Open Chrome with the extension and enable the MCP bridge in its popup (matching token & port)."},{"tool":"qa_status","ok":false,"ms":1,"bytes":0,"error":"tool reported an error: Qiksy extension is not connected. Open Chrome with the extension and enable the MCP bridge in its popup (matching token & port).\n\n{\n  \"whoFixesThis\": \"The human: the MCP-bridge toggle in the Qiksy pop"},{"tool":"qa_read","ok":false,"ms":1,"bytes":0,"error":"tool reported an error: Qiksy extension is not connected. Open Chrome with the extension and enable the MCP bridge in its popup (matching token & port).\n\n{\n  \"whoFixesThis\": \"The human: the MCP-bridge toggle in the Qiksy pop"},{"tool":"qa_help","ok":true,"ms":0,"bytes":23610},{"tool":"qa_recipe_list","ok":true,"ms":2,"bytes":91}],"host":{"commit":"eaaffffaf52255d1b77dc4aacffdfaf353f0c12c","run":"https://github.com/itsHaddad/bragproof/actions/runs/43857070216"},"network":{"names":["registry.npmjs.org"],"conns":[],"callNames":[],"callConns":[]}},"summary":{"outcome":"started","needs":[],"contacts":[],"flags":[{"kind":"orders","tool":"qa_steps","quote":"ou how to ask them to start one. PASSWORDS AND CARD NUMBERS NEVER APPEAR — a redacted field is written down by NAME, with its value replaced by a reference, at the m"},{"kind":"orders","tool":"qa_width_law","quote":"e at all; at 1920 the band is 1840, which is 440 wider». It NEVER says which of the two is right: that is the human's call, and an instrument that guesses it is one"},{"kind":"orders","tool":"qa_report_build","quote":"is the artefact this product exists to replace. EXPECTED IS NEVER INVENTED. Leave `expected` out and the field says «not stated — a person fills this in». Filling it"},{"kind":"orders","tool":"qa_failure_gallery","quote":"rror states do not have Qiksy and never will. The rules are ALWAYS removed at the end, including when something throws — a rule left behind outlives the reason for it"},{"kind":"orders","tool":"qa_screenshot","quote":"screenshot pasted into a ticket carries no secret. THE TAB MUST BE IN FRONT: the browser photographs the window's active tab, and Qiksy refuses to photograph a dif"},{"kind":"very-long","tool":"qa_fill_json","quote":"3000 characters or more"}],"tools":82,"wrote":0,"callsTried":5,"callsAnswered":2,"callContacts":[]},"history":[{"package":"qiksy-mcp","version":"1.86.0","ranAt":"2026-11-16T11:40:46.603Z","outcome":"started","tools":82,"contacts":0,"flags":6,"serious":0,"toolsHash":"655a4cfc1155ee5ee86123069813ef7249d73ce0db1d5cfe3c41562356e3c35a"}],"page":"https://bragproof.smaverk.com/r/qiksy-mcp"}