qiksy-mcp 1.63.0 → 1.64.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qiksy-mcp",
-  "version": "1.63.0",
+  "version": "1.64.0",
   "description": "Browser MCP server for the Chrome tab you already have open — your session, your logins. Gives Claude Code, Cursor, Codex and VS Code the live page: findings, forms, failed requests with server bodies.",
   "keywords": [
     "mcp",

package/server.mjs

@@ -1292,6 +1292,11 @@ function onConnection(ws, req) {
     // answer back under the follower's own id. Ours is a fresh randomUUID, so the two
     // id spaces cannot collide.
     if (msg.t === 'req' && isFollower) {
+      /* A REAL full stop from a sibling window or from `npx qiksy-mcp done` — the Stop hook's
+         route into this process. Our OWN estimate travels the same way when a follower guesses,
+         which is why the flag it carries is checked here: a guess must not teach the hub that
+         this setup reports its endings. */
+      if (msg.tool === 'qa_done' && !msg.args?.guessed) noteRealDone();
       callExtension(msg.tool, msg.args, msg.timeoutMs)
         .then((result) => safeSend(ws, { t: 'res', id: msg.id, ok: true, result }))
         .catch((err) => safeSend(ws, { t: 'res', id: msg.id, ok: false, error: err?.message || String(err) }));
@@ -1315,51 +1320,69 @@ function onConnection(ws, req) {
 let uiLanguage = '';
 
 /**
- * THE END OF A RUN, WITHOUT ANYBODY HAVING TO REMEMBER IT.
+ * GUESSING THE END OF A RUN — OFF BY DEFAULT SINCE 1.64.0, AND THE REASON IS WORTH KEEPING.
  *
- * `qa_done` is the verb that makes the tab pulse and the sound play, and the agent is asked to
- * call it in the instructions handed over at connect. An instruction is a request, though, not a
- * mechanism: some clients follow it, some do not, and every agent already installed has the old
- * habit. So the person updates, everything is switched on by default — and hears nothing. That is
- * the state this exists to prevent (owner, 21.09.2026).
+ * It was added on 21.09.2026 to cover clients that never call `qa_done`: the person updates,
+ * everything is on, and they hear nothing. The guess is silence — no bridge call for a while means
+ * the run is over — and it was defended as safe to be wrong, because a later call cancels the
+ * pulse and the extension refuses to sound twice in half a minute.
  *
- * What this process CAN observe is the same thing the voice already watches: it timestamps every
- * call and knows when the last one finished. A run that did real work and then went quiet past a
- * threshold is over in every sense that matters to somebody in the next room.
+ * THAT DEFENCE ONLY COVERED THE PULSE. A sound cannot be cancelled after it has been heard, and
+ * the silence it keys on is not silence at all: an agent that walked away from the browser to read
+ * files, edit code or think makes no bridge call for MINUTES while working flat out. So the signal
+ * arrived mid-run, and again on the next lull, and again — which is exactly what the owner
+ * reported hearing (28.09.2026: «звук отрабатывает, а агент продолжает маслать… QADone несколько
+ * раз отрабатывает, то есть он не по окончанию»). His ruling covers the mark as well as the
+ * sound: both announce the END of a task, so neither may fire on a guess.
  *
- * IT IS AN ESTIMATE, AND IT IS BUILT TO BE WRONG SAFELY. Three things make a premature signal
- * cheap rather than annoying, and none of them are new — they all shipped with the verb:
- *   · the extension refuses to sound when no work has been recorded;
- *   · it refuses to sound twice within half a minute;
- *   · ANY later call stops the pulse, so an agent that was merely thinking cancels the signal by
- *     carrying on — the mistake undoes itself without anybody touching anything.
- * The exact path — a Stop hook running `npx qiksy-mcp done` — stays available for clients that
- * have one, and is what `init` writes. This is the floor under it, not a replacement.
+ * A signal that is right most of the time is worse than no signal, because it is learned as noise
+ * and then switched off — taking the true ones with it.
+ *
+ * WHAT REPLACES IT IS NOT NOTHING. Two routes report a real full stop, and `connect` writes the
+ * second one into the client's settings, so an ordinary install has it:
+ *   · the agent calling `qa_done` itself, which every client is told about at `initialize`;
+ *   · a Stop hook running `npx qiksy-mcp done`, which fires whether or not the model remembered.
+ * The guess survives as an opt-in for a client that has neither: `QIKSY_MCP_DONE_AFTER=<seconds>`.
  */
 const DONE_AFTER_MS = (() => {
   const raw = process.env.QIKSY_MCP_DONE_AFTER;
-  if (raw === '0' || /^(off|no|false)$/i.test(raw || '')) return 0;
   const n = Number(raw);
   /* Below twenty seconds this would fire inside an ordinary pause for thought, so a smaller
-     number is read as a mistake and the default is used instead. */
-  return Number.isFinite(n) && n >= 20 ? n * 1000 : 90_000;
+     number is refused rather than honoured. Anything else, including nothing at all, is off. */
+  return Number.isFinite(n) && n >= 20 ? n * 1000 : 0;
 })();
 let doneTimer = null;
 let workSinceDone = false;
+/**
+ * A SETUP THAT REPORTS ITS OWN FULL STOP NEEDS NO GUESS, and the guess is the part that can be
+ * wrong. One real `qa_done` proves this client has a working route, so the estimate stands down
+ * for the rest of the process — nobody has to notice that they opted into both.
+ */
+let realDoneSeen = false;
+
+/** Called where a REAL full stop enters this process, and nowhere else — never from `fireDone`. */
+function noteRealDone() {
+  if (realDoneSeen) return;
+  realDoneSeen = true;
+  if (doneTimer) clearTimeout(doneTimer);
+  doneTimer = null;
+  workSinceDone = false;
+  if (DONE_AFTER_MS) log('▸ this setup announces the end of a run itself — the quiet-timer guess is off from here on');
+}
 
 function fireDone() {
   doneTimer = null;
-  if (!workSinceDone) return;
+  if (!workSinceDone || realDoneSeen) return;
   workSinceDone = false;
   log(`▸ quiet for ${Math.round(DONE_AFTER_MS / 1000)}s after a run — saying it has finished`);
   /* Failure here is nothing: the browser may have gone, the tab may have closed. The pulse is a
      courtesy, and a courtesy that throws is worse than one that does not happen. */
-  callExtension('qa_done', { verdict: 'ok' }, 8_000).catch(() => {});
+  callExtension('qa_done', { verdict: 'ok', guessed: true }, 8_000).catch(() => {});
 }
 
 /** Called when a call FINISHES, not when it starts: a slow verb must not look like silence. */
 function armDone(tool) {
-  if (!DONE_AFTER_MS) return;
+  if (!DONE_AFTER_MS || realDoneSeen) return;
   if (doneTimer) clearTimeout(doneTimer);
   doneTimer = null;
   if (tool === 'qa_done') {
@@ -7147,6 +7170,8 @@ server.registerTool(
   },
   async ({ tabId, verdict }) => {
     try {
+      /* The agent said it itself — the one route that needs no guessing behind it. */
+      noteRealDone();
       return asText(await callExtension('qa_done', { tabId, verdict }, 15_000));
     } catch (e) {
       /* The verb lives in the EXTENSION, which updates on the Web Store's clock while this server