@defend-tech/opencode-optima 0.1.83 → 0.1.85

package/dist/sanitize_cli.js

@@ -109,17 +109,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path20) {
-      const ctrl = callVisitor(key, node, visitor, path20);
+    function visit_(key, node, visitor, path23) {
+      const ctrl = callVisitor(key, node, visitor, path23);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path20, ctrl);
-        return visit_(key, ctrl, visitor, path20);
+        replaceNode(key, path23, ctrl);
+        return visit_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path20 = Object.freeze(path20.concat(node));
+          path23 = Object.freeze(path23.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path20);
+            const ci = visit_(i, node.items[i], visitor, path23);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -130,13 +130,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path20 = Object.freeze(path20.concat(node));
-          const ck = visit_("key", node.key, visitor, path20);
+          path23 = Object.freeze(path23.concat(node));
+          const ck = visit_("key", node.key, visitor, path23);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path20);
+          const cv = visit_("value", node.value, visitor, path23);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -157,17 +157,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path20) {
-      const ctrl = await callVisitor(key, node, visitor, path20);
+    async function visitAsync_(key, node, visitor, path23) {
+      const ctrl = await callVisitor(key, node, visitor, path23);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path20, ctrl);
-        return visitAsync_(key, ctrl, visitor, path20);
+        replaceNode(key, path23, ctrl);
+        return visitAsync_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path20 = Object.freeze(path20.concat(node));
+          path23 = Object.freeze(path23.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path20);
+            const ci = await visitAsync_(i, node.items[i], visitor, path23);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -178,13 +178,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path20 = Object.freeze(path20.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path20);
+          path23 = Object.freeze(path23.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path23);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path20);
+          const cv = await visitAsync_("value", node.value, visitor, path23);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -211,23 +211,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path20) {
+    function callVisitor(key, node, visitor, path23) {
       if (typeof visitor === "function")
-        return visitor(key, node, path20);
+        return visitor(key, node, path23);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path20);
+        return visitor.Map?.(key, node, path23);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path20);
+        return visitor.Seq?.(key, node, path23);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path20);
+        return visitor.Pair?.(key, node, path23);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path20);
+        return visitor.Scalar?.(key, node, path23);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path20);
+        return visitor.Alias?.(key, node, path23);
       return void 0;
     }
-    function replaceNode(key, path20, node) {
-      const parent = path20[path20.length - 1];
+    function replaceNode(key, path23, node) {
+      const parent = path23[path23.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -835,10 +835,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path20, value) {
+    function collectionFromPath(schema, path23, value) {
       let v = value;
-      for (let i = path20.length - 1; i >= 0; --i) {
-        const k = path20[i];
+      for (let i = path23.length - 1; i >= 0; --i) {
+        const k = path23[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -857,7 +857,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path20) => path20 == null || typeof path20 === "object" && !!path20[Symbol.iterator]().next().done;
+    var isEmptyPath = (path23) => path23 == null || typeof path23 === "object" && !!path23[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -887,11 +887,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path20, value) {
-        if (isEmptyPath(path20))
+      addIn(path23, value) {
+        if (isEmptyPath(path23))
           this.add(value);
         else {
-          const [key, ...rest] = path20;
+          const [key, ...rest] = path23;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -905,8 +905,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path20) {
-        const [key, ...rest] = path20;
+      deleteIn(path23) {
+        const [key, ...rest] = path23;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -920,8 +920,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path20, keepScalar) {
-        const [key, ...rest] = path20;
+      getIn(path23, keepScalar) {
+        const [key, ...rest] = path23;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -939,8 +939,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path20) {
-        const [key, ...rest] = path20;
+      hasIn(path23) {
+        const [key, ...rest] = path23;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -950,8 +950,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path20, value) {
-        const [key, ...rest] = path20;
+      setIn(path23, value) {
+        const [key, ...rest] = path23;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3455,9 +3455,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path20, value) {
+      addIn(path23, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path20, value);
+          this.contents.addIn(path23, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3532,14 +3532,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path20) {
-        if (Collection.isEmptyPath(path20)) {
+      deleteIn(path23) {
+        if (Collection.isEmptyPath(path23)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path20) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path23) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3554,10 +3554,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path20, keepScalar) {
-        if (Collection.isEmptyPath(path20))
+      getIn(path23, keepScalar) {
+        if (Collection.isEmptyPath(path23))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path20, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path23, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3568,10 +3568,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path20) {
-        if (Collection.isEmptyPath(path20))
+      hasIn(path23) {
+        if (Collection.isEmptyPath(path23))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path20) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path23) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3588,13 +3588,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path20, value) {
-        if (Collection.isEmptyPath(path20)) {
+      setIn(path23, value) {
+        if (Collection.isEmptyPath(path23)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path20), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path23), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path20, value);
+          this.contents.setIn(path23, value);
         }
       }
       /**
@@ -5546,9 +5546,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path20) => {
+    visit.itemAtPath = (cst, path23) => {
       let item = cst;
-      for (const [field, index] of path20) {
+      for (const [field, index] of path23) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5557,23 +5557,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path20) => {
-      const parent = visit.itemAtPath(cst, path20.slice(0, -1));
-      const field = path20[path20.length - 1][0];
+    visit.parentCollection = (cst, path23) => {
+      const parent = visit.itemAtPath(cst, path23.slice(0, -1));
+      const field = path23[path23.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path20, item, visitor) {
-      let ctrl = visitor(item, path20);
+    function _visit(path23, item, visitor) {
+      let ctrl = visitor(item, path23);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path20.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path23.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5584,10 +5584,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path20);
+            ctrl = ctrl(item, path23);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path20) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path23) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6872,14 +6872,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs19 = this.flowScalar(this.type);
+              const fs22 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs19, sep: [] });
+                map.items.push({ start, key: fs22, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs19);
+                this.stack.push(fs22);
               } else {
-                Object.assign(it, { key: fs19, sep: [] });
+                Object.assign(it, { key: fs22, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7007,13 +7007,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs19 = this.flowScalar(this.type);
+              const fs22 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs19, sep: [] });
+                fc.items.push({ start: [], key: fs22, sep: [] });
               else if (it.sep)
-                this.stack.push(fs19);
+                this.stack.push(fs22);
               else
-                Object.assign(it, { key: fs19, sep: [] });
+                Object.assign(it, { key: fs22, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7551,17 +7551,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path20, originalPath, doThrow) => {
-      if (!isString(path20)) {
+    var checkPath = (path23, originalPath, doThrow) => {
+      if (!isString(path23)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path20) {
+      if (!path23) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path20)) {
+      if (checkPath.isNotRelative(path23)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -7570,7 +7570,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path20) => REGEX_TEST_INVALID_PATH.test(path20);
+    var isNotRelative = (path23) => REGEX_TEST_INVALID_PATH.test(path23);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7629,7 +7629,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path20, checkUnignored) {
+      _testOne(path23, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -7637,7 +7637,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path20);
+          const matched = rule.regex.test(path23);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7650,24 +7650,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path20 = originalPath && checkPath.convert(originalPath);
+        const path23 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path20,
+          path23,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path20, cache, checkUnignored, slices);
+        return this._t(path23, cache, checkUnignored, slices);
       }
-      _t(path20, cache, checkUnignored, slices) {
-        if (path20 in cache) {
-          return cache[path20];
+      _t(path23, cache, checkUnignored, slices) {
+        if (path23 in cache) {
+          return cache[path23];
         }
         if (!slices) {
-          slices = path20.split(SLASH);
+          slices = path23.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path20] = this._testOne(path20, checkUnignored);
+          return cache[path23] = this._testOne(path23, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7675,24 +7675,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path20] = parent.ignored ? parent : this._testOne(path20, checkUnignored);
+        return cache[path23] = parent.ignored ? parent : this._testOne(path23, checkUnignored);
       }
-      ignores(path20) {
-        return this._test(path20, this._ignoreCache, false).ignored;
+      ignores(path23) {
+        return this._test(path23, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path20) => !this.ignores(path20);
+        return (path23) => !this.ignores(path23);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path20) {
-        return this._test(path20, this._testCache, true);
+      test(path23) {
+        return this._test(path23, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path20) => checkPath(path20 && checkPath.convert(path20), path20, RETURN_FALSE);
+    var isPathValid = (path23) => checkPath(path23 && checkPath.convert(path23), path23, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7703,22 +7703,22 @@ var require_ignore = __commonJS({
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path20) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path20) || isNotRelative(path20);
+      checkPath.isNotRelative = (path23) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path23) || isNotRelative(path23);
     }
   }
 });
 
 // src/sanitize_cli.js
-import fs18 from "node:fs";
-import os5 from "node:os";
-import path19 from "node:path";
+import fs21 from "node:fs";
+import os7 from "node:os";
+import path22 from "node:path";
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 
 // src/plugin.js
-import fs17 from "node:fs";
+import fs20 from "node:fs";
 var import_yaml6 = __toESM(require_dist(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import path18 from "node:path";
+import path21 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/agents.js
@@ -9962,8 +9962,8 @@ function clickUpWebhookLogPath(worktree) {
   return path7.join(optimaRuntimeDir(worktree), "clickup-webhook.log.jsonl");
 }
 function clickUpWebhookAuditLogDir() {
-  const dataHome = process.env.XDG_DATA_HOME && path7.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path7.join(os2.homedir(), ".local", "share", "opencode");
-  return path7.join(dataHome, "opencode-optima");
+  const dataHome2 = process.env.XDG_DATA_HOME && path7.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path7.join(os2.homedir(), ".local", "share", "opencode");
+  return path7.join(dataHome2, "opencode-optima");
 }
 function clickUpWebhookAuditLogPath(at = /* @__PURE__ */ new Date(), logDir = clickUpWebhookAuditLogDir()) {
   return path7.join(logDir, `clickup-webhook-${at.toISOString().slice(0, 10)}.jsonl`);
@@ -13506,11 +13506,668 @@ function createGitHubApiClient(config = {}, fetchImpl = globalThis.fetch) {
   };
 }
 
+// src/qa/chrome.js
+import fs17 from "node:fs";
+import os6 from "node:os";
+import path18 from "node:path";
+
+// src/qa/cdp.js
+import fs15 from "node:fs";
+import path16 from "node:path";
+var DEFAULT_CDP_URL = "http://127.0.0.1:9222";
+function normalizeBaseUrl(cdpUrl = "") {
+  return String(cdpUrl || process.env.OPTIMA_QA_CHROME_CDP_URL || DEFAULT_CDP_URL).trim().replace(/\/+$/, "");
+}
+async function cdpJson(baseUrl, route, options = {}) {
+  const response = await fetch(`${baseUrl}${route}`, options);
+  if (!response.ok) throw new Error(`cdp_http_${response.status}: ${route}`);
+  return response.json();
+}
+async function listCdpTargets({ cdpUrl = "" } = {}) {
+  const baseUrl = normalizeBaseUrl(cdpUrl);
+  return cdpJson(baseUrl, "/json/list");
+}
+async function cdpBrowserStatus({ cdpUrl = "", clickupTaskId = "", qaWindowName: qaWindowName2 = null } = {}) {
+  const targets = await listCdpTargets({ cdpUrl });
+  const pages = [];
+  for (let index = 0; index < targets.length; index += 1) {
+    const target = targets[index];
+    if (target.type !== "page") continue;
+    let windowName = "";
+    if (target.webSocketDebuggerUrl) {
+      const session = await CdpSession.connect(target.webSocketDebuggerUrl).catch(() => null);
+      if (session) {
+        try {
+          const evaluated = await session.evaluate("window.name || ''");
+          windowName = String(evaluated?.value || "");
+        } finally {
+          session.close();
+        }
+      }
+    }
+    pages.push({
+      index,
+      id: target.id,
+      role: index === 0 ? "persistent_session_tab" : qaWindowName2 && windowName === qaWindowName2(clickupTaskId) ? "qa_task_tab" : "other",
+      url: target.url,
+      title: target.title || "",
+      windowName
+    });
+  }
+  return { ok: true, pages, serviceWorkers: targets.filter((target) => target.type === "service_worker").map((target) => target.url) };
+}
+var CdpSession = class _CdpSession {
+  constructor(ws) {
+    this.ws = ws;
+    this.nextId = 1;
+    this.pending = /* @__PURE__ */ new Map();
+    this.ws.addEventListener("message", (event) => this.handleMessage(event));
+    this.ws.addEventListener("close", () => this.rejectAll(new Error("cdp_websocket_closed")));
+    this.ws.addEventListener("error", () => this.rejectAll(new Error("cdp_websocket_error")));
+  }
+  static connect(wsUrl, { timeoutMs = 1e4 } = {}) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(wsUrl);
+      const timer = setTimeout(() => {
+        try {
+          ws.close();
+        } catch {
+        }
+        reject(new Error("cdp_websocket_connect_timeout"));
+      }, timeoutMs);
+      ws.addEventListener("open", () => {
+        clearTimeout(timer);
+        resolve(new _CdpSession(ws));
+      }, { once: true });
+      ws.addEventListener("error", () => {
+        clearTimeout(timer);
+        reject(new Error("cdp_websocket_connect_failed"));
+      }, { once: true });
+    });
+  }
+  handleMessage(event) {
+    let message = null;
+    try {
+      message = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+    if (!message?.id || !this.pending.has(message.id)) return;
+    const pending = this.pending.get(message.id);
+    this.pending.delete(message.id);
+    clearTimeout(pending.timer);
+    if (message.error) pending.reject(new Error(`${message.error.message || "cdp_error"}${message.error.data ? `: ${message.error.data}` : ""}`));
+    else pending.resolve(message.result || {});
+  }
+  rejectAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+  send(method, params = {}, { timeoutMs = 3e4 } = {}) {
+    const id = this.nextId;
+    this.nextId += 1;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`cdp_command_timeout: ${method}`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      this.ws.send(JSON.stringify({ id, method, params }));
+    });
+  }
+  async evaluate(expression, { timeoutMs = 3e4 } = {}) {
+    const result = await this.send("Runtime.evaluate", {
+      expression,
+      awaitPromise: true,
+      returnByValue: true
+    }, { timeoutMs });
+    if (result.exceptionDetails) throw new Error(result.exceptionDetails.text || "runtime_evaluate_failed");
+    return result.result || null;
+  }
+  close() {
+    try {
+      this.ws.close();
+    } catch {
+    }
+  }
+};
+async function newCdpTarget({ cdpUrl = "", startUrl = "about:blank" } = {}) {
+  const baseUrl = normalizeBaseUrl(cdpUrl);
+  return cdpJson(baseUrl, `/json/new?${encodeURIComponent(startUrl)}`, { method: "PUT" });
+}
+async function targetWindowName(target) {
+  if (!target.webSocketDebuggerUrl) return "";
+  const session = await CdpSession.connect(target.webSocketDebuggerUrl);
+  try {
+    const value = await session.evaluate("window.name || ''");
+    return String(value?.value || "");
+  } finally {
+    session.close();
+  }
+}
+async function ensureCdpQaTarget({ cdpUrl = "", clickupTaskId = "", startUrl = "about:blank", qaWindowName: qaWindowName2 } = {}) {
+  const expected = qaWindowName2(clickupTaskId);
+  const targets = (await listCdpTargets({ cdpUrl })).filter((target2) => target2.type === "page");
+  for (let index = 1; index < targets.length; index += 1) {
+    if (await targetWindowName(targets[index]).catch(() => "") === expected) return targets[index];
+  }
+  const target = await newCdpTarget({ cdpUrl, startUrl });
+  const session = await CdpSession.connect(target.webSocketDebuggerUrl);
+  try {
+    await session.evaluate(`window.name = ${JSON.stringify(expected)}`);
+  } finally {
+    session.close();
+  }
+  return target;
+}
+function parseCdpCommand(commandJson = "") {
+  if (!String(commandJson || "").trim()) return { action: "status" };
+  try {
+    const parsed = JSON.parse(commandJson);
+    return parsed && typeof parsed === "object" ? parsed : { action: "invalid" };
+  } catch {
+    return { action: "script", script: String(commandJson || "") };
+  }
+}
+async function pageSnapshot(session) {
+  const evaluated = await session.evaluate("({ url: location.href, title: document.title })");
+  return evaluated?.value || { url: "", title: "" };
+}
+async function cdpRunChromeCommand({ cdpUrl = "", clickupTaskId = "", commandJson = "", startUrl = "about:blank", artifactsDir, qaWindowName: qaWindowName2 } = {}) {
+  const command = parseCdpCommand(commandJson);
+  const target = await ensureCdpQaTarget({ cdpUrl, clickupTaskId, startUrl, qaWindowName: qaWindowName2 });
+  const session = await CdpSession.connect(target.webSocketDebuggerUrl);
+  try {
+    const action = String(command.action || "status").toLowerCase();
+    let result = null;
+    if (action === "status") {
+      result = { ok: true, page: await pageSnapshot(session) };
+    } else if (action === "goto") {
+      await session.send("Page.enable");
+      await session.send("Page.navigate", { url: String(command.url || startUrl || "about:blank") });
+      if (command.wait_ms !== false) await new Promise((resolve) => setTimeout(resolve, Number(command.wait_ms || 1e3)));
+      result = { ok: true, page: await pageSnapshot(session) };
+    } else if (action === "evaluate") {
+      const evaluated = await session.evaluate(String(command.expression || "undefined"), { timeoutMs: Number(command.timeout_ms || 3e4) });
+      result = { ok: true, result: evaluated?.value ?? evaluated };
+    } else if (action === "screenshot") {
+      await session.send("Page.enable");
+      const captured = await session.send("Page.captureScreenshot", { format: command.format || "png", captureBeyondViewport: command.full_page !== false });
+      const name = String(command.name || `screenshot-${Date.now()}.png`).replace(/[^a-zA-Z0-9._-]+/g, "-");
+      const outPath = path16.join(artifactsDir, name);
+      fs15.mkdirSync(path16.dirname(outPath), { recursive: true });
+      fs15.writeFileSync(outPath, Buffer.from(captured.data || "", "base64"));
+      result = { ok: true, path: outPath };
+    } else if (action === "script") {
+      const script = String(command.script || "");
+      if (!script.trim()) return { ok: false, error: "script_required" };
+      const cdp = { send: (method, params = {}, options = {}) => session.send(method, params, options), evaluate: (expression, options = {}) => session.evaluate(expression, options) };
+      const fn = new Function("cdp", "target", "artifactsDir", "command", `return (async () => {
+${script}
+})()`);
+      result = { ok: true, result: await fn(cdp, target, artifactsDir, command) };
+    } else {
+      result = { ok: false, error: `unsupported_cdp_command_action: ${action}` };
+    }
+    return {
+      ok: result.ok !== false,
+      command: command.action || "script",
+      tab: { windowName: qaWindowName2(clickupTaskId), ...await pageSnapshot(session) },
+      artifactsDir,
+      result,
+      transport: "cdp"
+    };
+  } finally {
+    session.close();
+  }
+}
+async function cdpPrepareExtension({ cdpUrl = "", extensionId = "", reset = true, reload = true } = {}) {
+  const targets = await listCdpTargets({ cdpUrl });
+  const normalized = String(extensionId || "").trim();
+  const worker = targets.find((target) => target.type === "service_worker" && (!normalized || String(target.url || "").startsWith(`chrome-extension://${normalized}/`)));
+  if (!worker?.webSocketDebuggerUrl) return { ok: false, error: "extension_service_worker_not_found", serviceWorkers: targets.filter((target) => target.type === "service_worker").map((target) => target.url) };
+  const session = await CdpSession.connect(worker.webSocketDebuggerUrl);
+  try {
+    let resetResult = { ok: true, skipped: true };
+    let reloadResult = { ok: true, skipped: true };
+    if (reset) {
+      const evaluated = await session.evaluate(`(async () => {
+        const deletedCaches = [];
+        const deletedDbs = [];
+        if (globalThis.chrome?.storage?.local) await chrome.storage.local.clear();
+        if (globalThis.chrome?.storage?.session?.clear) await chrome.storage.session.clear();
+        if (globalThis.chrome?.storage?.sync) await chrome.storage.sync.clear();
+        if (globalThis.caches?.keys) {
+          for (const name of await caches.keys()) {
+            await caches.delete(name);
+            deletedCaches.push(name);
+          }
+        }
+        if (globalThis.indexedDB?.databases) {
+          for (const db of await indexedDB.databases()) {
+            if (db.name) {
+              indexedDB.deleteDatabase(db.name);
+              deletedDbs.push(db.name);
+            }
+          }
+        }
+        return { ok: true, deletedCaches, deletedDbs };
+      })()`);
+      resetResult = evaluated?.value || { ok: true };
+    }
+    if (reload) {
+      await session.evaluate("chrome.runtime.reload()");
+      reloadResult = { ok: true };
+    }
+    return { ok: true, reset: resetResult, reload: reloadResult };
+  } finally {
+    session.close();
+  }
+}
+
+// src/qa/queue.js
+import fs16 from "node:fs";
+import os5 from "node:os";
+import path17 from "node:path";
+var DEFAULT_QA_LEASE_MS = 5 * 60 * 1e3;
+var DEFAULT_QA_PROVIDER = "chatgpt";
+function dataHome() {
+  return process.env.XDG_DATA_HOME && path17.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path17.join(os5.homedir(), ".local", "share", "opencode");
+}
+function qaRuntimeDir() {
+  return path17.join(dataHome(), "opencode-optima", "qa");
+}
+function normalizeQaProvider(provider = DEFAULT_QA_PROVIDER) {
+  const normalized = String(provider || DEFAULT_QA_PROVIDER).trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-");
+  return normalized || DEFAULT_QA_PROVIDER;
+}
+function qaQueueStatePath(provider = DEFAULT_QA_PROVIDER) {
+  return path17.join(qaRuntimeDir(), `${normalizeQaProvider(provider)}-queue.json`);
+}
+function nowIso(now = /* @__PURE__ */ new Date()) {
+  return now instanceof Date ? now.toISOString() : new Date(now).toISOString();
+}
+function normalizeClickUpTaskId(value = "") {
+  return String(value || "").trim();
+}
+function emptyQaQueueState(provider = DEFAULT_QA_PROVIDER) {
+  return {
+    provider: normalizeQaProvider(provider),
+    active: null,
+    queue: [],
+    history: []
+  };
+}
+function readQaQueueState(provider = DEFAULT_QA_PROVIDER, statePath = qaQueueStatePath(provider)) {
+  try {
+    const raw = fs16.readFileSync(statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isPlainObject(parsed)) return emptyQaQueueState(provider);
+    return {
+      ...emptyQaQueueState(provider),
+      ...parsed,
+      provider: normalizeQaProvider(parsed.provider || provider),
+      queue: Array.isArray(parsed.queue) ? parsed.queue.filter(isPlainObject) : [],
+      history: Array.isArray(parsed.history) ? parsed.history.filter(isPlainObject).slice(-50) : []
+    };
+  } catch {
+    return emptyQaQueueState(provider);
+  }
+}
+function writeQaQueueState(state, statePath = qaQueueStatePath(state?.provider)) {
+  const normalized = {
+    ...emptyQaQueueState(state?.provider),
+    ...state,
+    provider: normalizeQaProvider(state?.provider),
+    queue: Array.isArray(state?.queue) ? state.queue.filter(isPlainObject) : [],
+    history: Array.isArray(state?.history) ? state.history.filter(isPlainObject).slice(-50) : []
+  };
+  fs16.mkdirSync(path17.dirname(statePath), { recursive: true });
+  fs16.writeFileSync(statePath, `${JSON.stringify(normalized, null, 2)}
+`, { mode: 384 });
+  return normalized;
+}
+function activeExpired(active, nowMs, leaseMs) {
+  if (!active?.clickupTaskId) return false;
+  const last = Date.parse(active.lastActivityAt || active.grantedAt || "");
+  return Number.isFinite(last) && nowMs - last > leaseMs;
+}
+function queuedIndex(state, clickupTaskId) {
+  return state.queue.findIndex((entry) => entry.clickupTaskId === clickupTaskId);
+}
+function queueEntry({ clickupTaskId, sessionId = "", worktree = "", reason = "", now = /* @__PURE__ */ new Date() } = {}) {
+  return {
+    clickupTaskId,
+    sessionId: String(sessionId || "").trim(),
+    worktree: String(worktree || "").trim(),
+    reason: String(reason || "").trim(),
+    queuedAt: nowIso(now),
+    lastRequestAt: nowIso(now)
+  };
+}
+function activeEntry({ provider, clickupTaskId, sessionId = "", worktree = "", leaseMs = DEFAULT_QA_LEASE_MS, now = /* @__PURE__ */ new Date() } = {}) {
+  return {
+    provider: normalizeQaProvider(provider),
+    clickupTaskId,
+    sessionId: String(sessionId || "").trim(),
+    worktree: String(worktree || "").trim(),
+    grantedAt: nowIso(now),
+    lastActivityAt: nowIso(now),
+    leaseMs
+  };
+}
+function releaseExpiredQaSlot(state, { now = /* @__PURE__ */ new Date(), leaseMs = DEFAULT_QA_LEASE_MS } = {}) {
+  const normalized = { ...emptyQaQueueState(state?.provider), ...state, queue: Array.isArray(state?.queue) ? [...state.queue] : [] };
+  if (!activeExpired(normalized.active, now.getTime(), leaseMs)) return { state: normalized, expired: null, promoted: null };
+  const expired = normalized.active;
+  normalized.history = [...normalized.history || [], { action: "expired", clickupTaskId: expired.clickupTaskId, at: nowIso(now) }].slice(-50);
+  normalized.active = null;
+  const promoted = normalized.queue.shift() || null;
+  if (promoted) {
+    normalized.active = activeEntry({ ...promoted, provider: normalized.provider, leaseMs, now });
+    normalized.history = [...normalized.history || [], { action: "promoted", clickupTaskId: promoted.clickupTaskId, at: nowIso(now), reason: "expired_previous_slot" }].slice(-50);
+  }
+  return { state: normalized, expired, promoted };
+}
+function requestQaSlot(state, { clickupTaskId, sessionId = "", worktree = "", reason = "", now = /* @__PURE__ */ new Date(), leaseMs = DEFAULT_QA_LEASE_MS } = {}) {
+  const taskId = normalizeClickUpTaskId(clickupTaskId);
+  if (!taskId) return { state, ok: false, action: "invalid", reason: "clickup_task_id_required" };
+  let next = { ...emptyQaQueueState(state?.provider), ...state, queue: Array.isArray(state?.queue) ? [...state.queue] : [] };
+  const expiredResult = releaseExpiredQaSlot(next, { now, leaseMs });
+  next = expiredResult.state;
+  if (!next.active) {
+    next.active = activeEntry({ provider: next.provider, clickupTaskId: taskId, sessionId, worktree, leaseMs, now });
+    next.queue = next.queue.filter((entry) => entry.clickupTaskId !== taskId);
+    next.history = [...next.history || [], { action: "granted", clickupTaskId: taskId, at: nowIso(now) }].slice(-50);
+    return { state: next, ok: true, action: "granted", active: next.active, expired: expiredResult.expired, promoted: expiredResult.promoted };
+  }
+  if (next.active.clickupTaskId === taskId) {
+    next.active = { ...next.active, sessionId: sessionId || next.active.sessionId || "", worktree: worktree || next.active.worktree || "", lastActivityAt: nowIso(now), leaseMs };
+    next.history = [...next.history || [], { action: "renewed", clickupTaskId: taskId, at: nowIso(now) }].slice(-50);
+    return { state: next, ok: true, action: "granted_existing", active: next.active, expired: expiredResult.expired, promoted: expiredResult.promoted };
+  }
+  const index = queuedIndex(next, taskId);
+  if (index >= 0) {
+    next.queue[index] = { ...next.queue[index], sessionId: sessionId || next.queue[index].sessionId || "", worktree: worktree || next.queue[index].worktree || "", reason: reason || next.queue[index].reason || "", lastRequestAt: nowIso(now) };
+  } else {
+    next.queue.push(queueEntry({ clickupTaskId: taskId, sessionId, worktree, reason, now }));
+  }
+  return {
+    state: next,
+    ok: false,
+    action: "queued",
+    active: next.active,
+    position: queuedIndex(next, taskId) + 1,
+    expired: expiredResult.expired,
+    promoted: expiredResult.promoted
+  };
+}
+function touchQaSlot(state, { clickupTaskId, now = /* @__PURE__ */ new Date(), leaseMs = DEFAULT_QA_LEASE_MS } = {}) {
+  const taskId = normalizeClickUpTaskId(clickupTaskId);
+  let next = { ...emptyQaQueueState(state?.provider), ...state, queue: Array.isArray(state?.queue) ? [...state.queue] : [] };
+  const expiredResult = releaseExpiredQaSlot(next, { now, leaseMs });
+  next = expiredResult.state;
+  if (!next.active || next.active.clickupTaskId !== taskId) return { state: next, ok: false, action: "not_active_holder", active: next.active, expired: expiredResult.expired, promoted: expiredResult.promoted };
+  next.active = { ...next.active, lastActivityAt: nowIso(now), leaseMs };
+  return { state: next, ok: true, action: "touched", active: next.active, expired: expiredResult.expired, promoted: expiredResult.promoted };
+}
+function finishQaSlot(state, { clickupTaskId, now = /* @__PURE__ */ new Date(), leaseMs = DEFAULT_QA_LEASE_MS } = {}) {
+  const taskId = normalizeClickUpTaskId(clickupTaskId);
+  let next = { ...emptyQaQueueState(state?.provider), ...state, queue: Array.isArray(state?.queue) ? [...state.queue] : [] };
+  const expiredResult = releaseExpiredQaSlot(next, { now, leaseMs });
+  next = expiredResult.state;
+  if (!next.active || next.active.clickupTaskId !== taskId) return { state: next, ok: false, action: "not_active_holder", active: next.active, expired: expiredResult.expired, promoted: expiredResult.promoted };
+  const released = next.active;
+  next.active = null;
+  next.history = [...next.history || [], { action: "finished", clickupTaskId: taskId, at: nowIso(now) }].slice(-50);
+  const promoted = next.queue.shift() || null;
+  if (promoted) {
+    next.active = activeEntry({ ...promoted, provider: next.provider, leaseMs, now });
+    next.history = [...next.history || [], { action: "promoted", clickupTaskId: promoted.clickupTaskId, at: nowIso(now), reason: "previous_finished" }].slice(-50);
+  }
+  return { state: next, ok: true, action: "finished", released, promoted };
+}
+
+// src/qa/chrome.js
+var DEFAULT_QA_CDP_URL = "http://127.0.0.1:9222";
+var DEFAULT_QA_PLAYWRIGHT_CONNECT_TIMEOUT_MS = 5e3;
+function providerDir(provider = DEFAULT_QA_PROVIDER) {
+  return path18.join(qaRuntimeDir(), normalizeQaProvider(provider));
+}
+function defaultQaExtensionStageDir(provider = DEFAULT_QA_PROVIDER) {
+  return path18.join(providerDir(provider), "extension-under-test");
+}
+function defaultQaArtifactsDir(provider = DEFAULT_QA_PROVIDER, clickupTaskId = "unknown") {
+  return path18.join(providerDir(provider), "artifacts", String(clickupTaskId || "unknown"));
+}
+function normalizeCdpUrl(value = "") {
+  return String(value || process.env.OPTIMA_QA_CHROME_CDP_URL || DEFAULT_QA_CDP_URL).trim() || DEFAULT_QA_CDP_URL;
+}
+async function loadPlaywrightChromium() {
+  try {
+    const mod = await import("playwright-core");
+    return mod.chromium;
+  } catch (error) {
+    throw new Error(`playwright-core is required for Optima QA browser tools: ${error.message}`);
+  }
+}
+function qaWindowName(clickupTaskId) {
+  return `optima-qa:${String(clickupTaskId || "").trim()}`;
+}
+async function safePageWindowName(page) {
+  try {
+    return await page.evaluate(() => window.name || "");
+  } catch {
+    return "";
+  }
+}
+async function findQaPage(context, clickupTaskId) {
+  const expected = qaWindowName(clickupTaskId);
+  const pages = context.pages();
+  for (let index = 1; index < pages.length; index += 1) {
+    const page = pages[index];
+    if (await safePageWindowName(page) === expected) return page;
+  }
+  return null;
+}
+async function ensurePersistentTab(context, url = "https://chatgpt.com/") {
+  const pages = context.pages();
+  if (pages[0]) return pages[0];
+  const page = await context.newPage();
+  await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
+  });
+  return page;
+}
+async function ensureQaPage(context, { clickupTaskId, startUrl = "https://chatgpt.com/" } = {}) {
+  await ensurePersistentTab(context, startUrl);
+  const existing = await findQaPage(context, clickupTaskId);
+  if (existing) return existing;
+  const page = await context.newPage();
+  await page.goto(startUrl, { waitUntil: "domcontentloaded", timeout: 3e4 }).catch(() => {
+  });
+  await page.evaluate((name) => {
+    window.name = name;
+  }, qaWindowName(clickupTaskId)).catch(() => {
+  });
+  return page;
+}
+function copyExtensionSource(sourcePath, stageDir) {
+  const source = String(sourcePath || "").trim();
+  if (!source) return { ok: true, skipped: true, reason: "extension_path_not_provided", stageDir };
+  const resolved = path18.resolve(source.replace(/^~(?=$|\/)/, os6.homedir()));
+  if (!fs17.existsSync(resolved)) return { ok: false, error: `extension_path_not_found: ${resolved}`, stageDir };
+  fs17.rmSync(stageDir, { recursive: true, force: true });
+  fs17.mkdirSync(path18.dirname(stageDir), { recursive: true });
+  fs17.cpSync(resolved, stageDir, {
+    recursive: true,
+    filter: (src) => !/[/\\](node_modules|\.git|dist|build|test-results)([/\\]|$)/.test(src)
+  });
+  return { ok: true, source: resolved, stageDir };
+}
+function extensionIdFromWorkerUrl(url = "") {
+  const match = String(url || "").match(/^chrome-extension:\/\/([^/]+)/);
+  return match?.[1] || "";
+}
+async function findExtensionWorker(context, extensionId = "") {
+  const workers = context.serviceWorkers ? context.serviceWorkers() : [];
+  const normalized = String(extensionId || "").trim();
+  if (normalized) return workers.find((worker) => worker.url().startsWith(`chrome-extension://${normalized}/`)) || null;
+  return workers.find((worker) => String(worker.url()).startsWith("chrome-extension://")) || null;
+}
+async function resetExtensionState(context, { extensionId = "" } = {}) {
+  const worker = await findExtensionWorker(context, extensionId);
+  if (!worker) return { ok: false, error: "extension_service_worker_not_found" };
+  const id = extensionIdFromWorkerUrl(worker.url());
+  const result = await worker.evaluate(async () => {
+    const deletedCaches = [];
+    const deletedDbs = [];
+    if (globalThis.chrome?.storage?.local) await chrome.storage.local.clear();
+    if (globalThis.chrome?.storage?.session?.clear) await chrome.storage.session.clear();
+    if (globalThis.chrome?.storage?.sync) await chrome.storage.sync.clear();
+    if (globalThis.caches?.keys) {
+      for (const name of await caches.keys()) {
+        await caches.delete(name);
+        deletedCaches.push(name);
+      }
+    }
+    if (globalThis.indexedDB?.databases) {
+      for (const db of await indexedDB.databases()) {
+        if (db.name) {
+          indexedDB.deleteDatabase(db.name);
+          deletedDbs.push(db.name);
+        }
+      }
+    }
+    return { ok: true, deletedCaches, deletedDbs };
+  });
+  return { extensionId: id, ...result };
+}
+async function reloadExtension(context, { extensionId = "" } = {}) {
+  const worker = await findExtensionWorker(context, extensionId);
+  if (!worker) return { ok: false, error: "extension_service_worker_not_found" };
+  const id = extensionIdFromWorkerUrl(worker.url());
+  await worker.evaluate(() => chrome.runtime.reload()).catch(() => {
+  });
+  return { ok: true, extensionId: id };
+}
+async function summarizeBrowser(context, { clickupTaskId = "" } = {}) {
+  const pages = context.pages();
+  const pageSummaries = [];
+  for (let index = 0; index < pages.length; index += 1) {
+    const page = pages[index];
+    pageSummaries.push({
+      index,
+      role: index === 0 ? "persistent_session_tab" : await safePageWindowName(page) === qaWindowName(clickupTaskId) ? "qa_task_tab" : "other",
+      url: page.url(),
+      title: await page.title().catch(() => "")
+    });
+  }
+  const workers = context.serviceWorkers ? context.serviceWorkers().map((worker) => worker.url()) : [];
+  return { pages: pageSummaries, serviceWorkers: workers };
+}
+function parseQaCommand(commandJson = "") {
+  if (!String(commandJson || "").trim()) return { action: "status" };
+  try {
+    const parsed = JSON.parse(commandJson);
+    return parsed && typeof parsed === "object" ? parsed : { action: "invalid", error: "command_json_must_be_object" };
+  } catch (error) {
+    return { action: "script", script: String(commandJson || "") };
+  }
+}
+async function runQaCommandOnPage(page, context, browser, command, { artifactsDir }) {
+  const action = String(command.action || "status").trim().toLowerCase();
+  if (action === "status") return { ok: true, page: { url: page.url(), title: await page.title().catch(() => "") } };
+  if (action === "goto") {
+    await page.goto(String(command.url || "https://chatgpt.com/"), { waitUntil: command.wait_until || "domcontentloaded", timeout: Number(command.timeout_ms || 3e4) });
+    return { ok: true, url: page.url(), title: await page.title().catch(() => "") };
+  }
+  if (action === "evaluate") {
+    const result = await page.evaluate(String(command.expression || "() => null"));
+    return { ok: true, result };
+  }
+  if (action === "screenshot") {
+    const name = String(command.name || `screenshot-${Date.now()}.png`).replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const outPath = path18.join(artifactsDir, name);
+    fs17.mkdirSync(path18.dirname(outPath), { recursive: true });
+    await page.screenshot({ path: outPath, fullPage: command.full_page !== false });
+    return { ok: true, path: outPath };
+  }
+  if (action === "set_input_files") {
+    const selector = String(command.selector || "input[type=file]");
+    await page.setInputFiles(selector, command.files);
+    return { ok: true, selector };
+  }
+  if (action === "script") {
+    const script = String(command.script || "");
+    if (!script.trim()) return { ok: false, error: "script_required" };
+    const fn = new Function("page", "context", "browser", "artifactsDir", `return (async () => {
+${script}
+})()`);
+    const result = await fn(page, context, browser, artifactsDir);
+    return { ok: true, result };
+  }
+  return { ok: false, error: `unsupported_qa_command_action: ${action}` };
+}
+async function withQaBrowser({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "", clickupTaskId = "", startUrl = "https://chatgpt.com/" } = {}, callback) {
+  const chromium = await loadPlaywrightChromium();
+  const browser = await chromium.connectOverCDP(normalizeCdpUrl(cdpUrl), {
+    timeout: Number(process.env.OPTIMA_QA_PLAYWRIGHT_CONNECT_TIMEOUT_MS || DEFAULT_QA_PLAYWRIGHT_CONNECT_TIMEOUT_MS)
+  });
+  try {
+    const context = browser.contexts()[0] || await browser.newContext();
+    const page = clickupTaskId ? await ensureQaPage(context, { clickupTaskId, startUrl }) : null;
+    return await callback({ browser, context, page });
+  } finally {
+    await browser.close().catch(() => {
+    });
+  }
+}
+async function qaBrowserStatus(options = {}) {
+  return withQaBrowser(options, async ({ context }) => ({ ok: true, ...await summarizeBrowser(context, { clickupTaskId: options.clickupTaskId }) })).catch(async (error) => {
+    const fallback = await cdpBrowserStatus({ cdpUrl: options.cdpUrl, clickupTaskId: options.clickupTaskId, qaWindowName }).catch((fallbackError) => ({ ok: false, error: fallbackError.message }));
+    return fallback.ok ? { ...fallback, fallback: "cdp", playwrightError: error.message } : { ok: false, error: error.message, fallbackError: fallback.error, cdpUrl: normalizeCdpUrl(options.cdpUrl) };
+  });
+}
+async function qaPrepareExtension({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "", extensionPath = "", extensionId = "", reset = true, reload = true } = {}) {
+  const stageDir = defaultQaExtensionStageDir(provider);
+  const sync = copyExtensionSource(extensionPath, stageDir);
+  const browserResult = await withQaBrowser({ provider, cdpUrl }, async ({ context }) => {
+    const resetResult = reset ? await resetExtensionState(context, { extensionId }).catch((error) => ({ ok: false, error: error.message })) : { ok: true, skipped: true };
+    const reloadResult = reload ? await reloadExtension(context, { extensionId }).catch((error) => ({ ok: false, error: error.message })) : { ok: true, skipped: true };
+    return { reset: resetResult, reload: reloadResult, browser: await summarizeBrowser(context) };
+  }).catch(async (error) => {
+    const fallback = await cdpPrepareExtension({ cdpUrl, extensionId, reset, reload }).catch((fallbackError) => ({ ok: false, error: fallbackError.message }));
+    return fallback.ok ? { ...fallback, fallback: "cdp", playwrightError: error.message } : { ok: false, error: error.message, fallbackError: fallback.error };
+  });
+  return { sync, ...browserResult };
+}
+async function qaRunChromeCommand({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "", clickupTaskId = "", commandJson = "", startUrl = "https://chatgpt.com/" } = {}) {
+  const command = parseQaCommand(commandJson);
+  const artifactsDir = defaultQaArtifactsDir(provider, clickupTaskId);
+  return withQaBrowser({ provider, cdpUrl, clickupTaskId, startUrl }, async ({ browser, context, page }) => {
+    const result = await runQaCommandOnPage(page, context, browser, command, { artifactsDir });
+    return { ok: result.ok !== false, command: command.action || "script", tab: { windowName: qaWindowName(clickupTaskId), url: page.url(), title: await page.title().catch(() => "") }, artifactsDir, result };
+  }).catch(async (error) => {
+    const fallback = await cdpRunChromeCommand({
+      cdpUrl,
+      clickupTaskId,
+      commandJson,
+      startUrl,
+      artifactsDir,
+      qaWindowName
+    }).catch((fallbackError) => ({ ok: false, error: fallbackError.message }));
+    return fallback.ok ? { ...fallback, fallback: "cdp", playwrightError: error.message } : { ok: false, error: error.message, fallbackError: fallback.error };
+  });
+}
+
 // src/repair.js
 var import_yaml4 = __toESM(require_dist(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
-import fs15 from "node:fs";
-import path16 from "node:path";
+import fs18 from "node:fs";
+import path19 from "node:path";
 var CODEMAP_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".ts",
@@ -13548,10 +14205,10 @@ var LEGACY_OPERATIONAL_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var OPTIMA_OPERATIONAL_FOLDERS = [".optima", "templates", "dist"];
 function relPath(worktree, targetPath) {
-  return path16.relative(worktree, targetPath).split(path16.sep).join("/") || ".";
+  return path19.relative(worktree, targetPath).split(path19.sep).join("/") || ".";
 }
 function normalizeCodemapRelPath(relPathValue) {
-  return path16.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
+  return path19.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
 }
 function firstPathSegment(relPathValue) {
   return normalizeCodemapRelPath(relPathValue).split("/").filter(Boolean)[0] || "";
@@ -13570,8 +14227,8 @@ function isHiddenTree(relPathValue) {
 function loadGitIgnoreMatcher(worktree) {
   const ig = (0, import_ignore.default)();
   ig.add(".git");
-  const gitignorePath = path16.join(worktree, ".gitignore");
-  if (fs15.existsSync(gitignorePath)) ig.add(fs15.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path19.join(worktree, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) ig.add(fs18.readFileSync(gitignorePath, "utf8"));
   return ig;
 }
 function codemapSectionEntries(value) {
@@ -13590,7 +14247,7 @@ function codemapIndexedPaths(map) {
 }
 function readCodemap(filePath, unresolved, worktree) {
   try {
-    const parsed = import_yaml4.default.parse(fs15.readFileSync(filePath, "utf8"));
+    const parsed = import_yaml4.default.parse(fs18.readFileSync(filePath, "utf8"));
     if (!parsed || typeof parsed !== "object") {
       unresolved.push({ category: "codemap", path: relPath(worktree, filePath), message: "CodeMap is empty or invalid; manual repair required." });
       return null;
@@ -13602,42 +14259,42 @@ function readCodemap(filePath, unresolved, worktree) {
   }
 }
 function writeCodemap(filePath, map) {
-  fs15.writeFileSync(filePath, import_yaml4.default.stringify(map), "utf8");
+  fs18.writeFileSync(filePath, import_yaml4.default.stringify(map), "utf8");
 }
 function isIgnoredPath(ig, relativePath) {
   const normalized = normalizeCodemapRelPath(relativePath);
   return Boolean(normalized) && ig.ignores(normalized);
 }
 function hasImmediateSourceFile(dirPath, ig, worktree) {
-  if (!fs15.existsSync(dirPath)) return false;
-  for (const item of fs15.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path16.join(dirPath, item.name);
-    const relative = path16.relative(worktree, childPath);
+  if (!fs18.existsSync(dirPath)) return false;
+  for (const item of fs18.readdirSync(dirPath, { withFileTypes: true })) {
+    const childPath = path19.join(dirPath, item.name);
+    const relative = path19.relative(worktree, childPath);
     if (isIgnoredPath(ig, relative) || isOperationalRelPath(relative)) continue;
-    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path16.extname(item.name))) return true;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path19.extname(item.name))) return true;
   }
   return false;
 }
 function containsSource(dirPath, ig, worktree) {
-  if (!fs15.existsSync(dirPath)) return false;
-  const dirRelPath = path16.relative(worktree, dirPath);
+  if (!fs18.existsSync(dirPath)) return false;
+  const dirRelPath = path19.relative(worktree, dirPath);
   if (isOperationalRelPath(dirRelPath) || isHiddenTree(dirRelPath)) return false;
-  for (const item of fs15.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path16.join(dirPath, item.name);
-    const relative = path16.relative(worktree, childPath);
+  for (const item of fs18.readdirSync(dirPath, { withFileTypes: true })) {
+    const childPath = path19.join(dirPath, item.name);
+    const relative = path19.relative(worktree, childPath);
     if (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative)) continue;
-    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path16.extname(item.name))) return true;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path19.extname(item.name))) return true;
     if (item.isDirectory() && containsSource(childPath, ig, worktree)) return true;
   }
   return false;
 }
 function createModuleCodemap(dirPath, worktree, deps) {
-  const entries = fs15.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs18.readdirSync(dirPath, { withFileTypes: true });
   const entrypoints = [];
   const internals = [];
-  const relToRoot = path16.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path16.sep).join("/");
+  const relToRoot = path19.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path19.sep).join("/");
   for (const item of entries) {
-    if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path16.extname(item.name))) continue;
+    if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path19.extname(item.name))) continue;
     const bucket = /^index\.(js|ts|tsx|jsx)$|^main\.(js|ts|tsx|jsx|py|go|rs|java)$/.test(item.name) ? entrypoints : internals;
     bucket.push({ path: item.name });
   }
@@ -13650,7 +14307,7 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
   const map = readCodemap(codemapPath, unresolved, worktree);
   if (!map) return;
   const isRootMap = codemapPath === deps.optimaCodemapPath(worktree);
-  const mapDir = path16.dirname(codemapPath);
+  const mapDir = path19.dirname(codemapPath);
   const pathBase = isRootMap ? worktree : mapDir;
   let changed = false;
   for (const section of ["modules", "entrypoints", "sources_of_truth", "links", "internals"]) {
@@ -13661,13 +14318,13 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
     }
     const nextEntries = [];
     for (const entry of originalEntries) {
-      if (!entry?.path || entry.path.startsWith("http://") || entry.path.startsWith("https://") || path16.isAbsolute(entry.path)) {
+      if (!entry?.path || entry.path.startsWith("http://") || entry.path.startsWith("https://") || path19.isAbsolute(entry.path)) {
         nextEntries.push(entry);
         continue;
       }
       const normalizedPath = normalizeCodemapRelPath(entry.path);
-      const absPath = path16.join(pathBase, normalizedPath);
-      if (!fs15.existsSync(absPath)) {
+      const absPath = path19.join(pathBase, normalizedPath);
+      if (!fs18.existsSync(absPath)) {
         registerAction({ category: "codemap", action: apply ? "removed" : "would_remove", path: relPath(worktree, codemapPath), detail: `Remove broken ${section.slice(0, -1)} reference '${entry.path}'.` });
         changed = true;
         continue;
@@ -13676,8 +14333,8 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
       const maxParts = isRootMap ? 2 : 1;
       if (parts.length > maxParts) {
         const localPath = isRootMap ? parts.slice(0, 2).join("/") : parts[0];
-        const localAbs = path16.join(pathBase, localPath);
-        if (fs15.existsSync(localAbs)) {
+        const localAbs = path19.join(pathBase, localPath);
+        if (fs18.existsSync(localAbs)) {
           nextEntries.push({ ...entry, path: localPath });
           changed = true;
           registerAction({ category: "codemap", action: apply ? "updated" : "would_update", path: relPath(worktree, codemapPath), detail: `Shorten '${entry.path}' to local path '${localPath}'.` });
@@ -13691,11 +14348,11 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
     }
     if (Array.isArray(map[section])) map[section] = nextEntries;
   }
-  if (map.scope === "module" && !isOperationalRelPath(path16.relative(worktree, mapDir))) {
+  if (map.scope === "module" && !isOperationalRelPath(path19.relative(worktree, mapDir))) {
     const indexed = codemapIndexedPaths(map);
     const internals = Array.isArray(map.internals) ? map.internals : [];
-    for (const item of fs15.readdirSync(mapDir, { withFileTypes: true })) {
-      if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path16.extname(item.name))) continue;
+    for (const item of fs18.readdirSync(mapDir, { withFileTypes: true })) {
+      if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path19.extname(item.name))) continue;
       if (indexed.has(item.name)) continue;
       internals.push({ path: item.name });
       indexed.add(item.name);
@@ -13709,13 +14366,13 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
 function repairCodemaps(worktree, apply, actions, unresolved, deps) {
   const ig = loadGitIgnoreMatcher(worktree);
   const rootCodemapPath = deps.optimaCodemapPath(worktree);
-  const rootCodemapMissing = !fs15.existsSync(rootCodemapPath);
+  const rootCodemapMissing = !fs18.existsSync(rootCodemapPath);
   if (rootCodemapMissing) {
     actions.push({ category: "codemap", action: apply ? "created" : "would_create", path: ".optima/codemap.yml", detail: "Create missing root CodeMap from template." });
     if (apply) deps.scaffoldOptimaRootCodemap(worktree);
   }
-  if (fs15.existsSync(rootCodemapPath)) repairSingleCodemap(rootCodemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-  const rootMap = fs15.existsSync(rootCodemapPath) ? readCodemap(rootCodemapPath, unresolved, worktree) : null;
+  if (fs18.existsSync(rootCodemapPath)) repairSingleCodemap(rootCodemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
+  const rootMap = fs18.existsSync(rootCodemapPath) ? readCodemap(rootCodemapPath, unresolved, worktree) : null;
   let rootChanged = false;
   const rootModulesRepairable = rootMap && (rootMap.modules === void 0 || Array.isArray(rootMap.modules));
   if (rootMap) {
@@ -13727,10 +14384,10 @@ function repairCodemaps(worktree, apply, actions, unresolved, deps) {
     }
   }
   function walk(dirPath) {
-    const relative = path16.relative(worktree, dirPath);
+    const relative = path19.relative(worktree, dirPath);
     if (relative && (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative))) return;
-    const codemapPath = path16.join(dirPath, "codemap.yml");
-    const hasCodemap = fs15.existsSync(codemapPath);
+    const codemapPath = path19.join(dirPath, "codemap.yml");
+    const hasCodemap = fs18.existsSync(codemapPath);
     const sourceDir = relative && containsSource(dirPath, ig, worktree);
     if (sourceDir && !hasCodemap && dirPath !== worktree) {
       if (hasImmediateSourceFile(dirPath, ig, worktree)) {
@@ -13749,19 +14406,19 @@ function repairCodemaps(worktree, apply, actions, unresolved, deps) {
         actions.push({ category: "codemap", action: apply ? "updated" : "would_update", path: ".optima/codemap.yml", detail: `Register top-level source module '${normalizeCodemapRelPath(relative)}'.` });
       }
     }
-    if (fs15.existsSync(codemapPath) && codemapPath !== rootCodemapPath) repairSingleCodemap(codemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-    for (const item of fs15.readdirSync(dirPath, { withFileTypes: true })) {
-      if (item.isDirectory()) walk(path16.join(dirPath, item.name));
+    if (fs18.existsSync(codemapPath) && codemapPath !== rootCodemapPath) repairSingleCodemap(codemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
+    for (const item of fs18.readdirSync(dirPath, { withFileTypes: true })) {
+      if (item.isDirectory()) walk(path19.join(dirPath, item.name));
     }
   }
-  if (fs15.existsSync(worktree)) walk(worktree);
+  if (fs18.existsSync(worktree)) walk(worktree);
   if (rootMap && rootChanged && apply) writeCodemap(rootCodemapPath, rootMap);
 }
 function walkMarkdownFiles(dirPath) {
-  if (!fs15.existsSync(dirPath)) return [];
+  if (!fs18.existsSync(dirPath)) return [];
   const files = [];
-  for (const entry of fs15.readdirSync(dirPath, { withFileTypes: true })) {
-    const entryPath = path16.join(dirPath, entry.name);
+  for (const entry of fs18.readdirSync(dirPath, { withFileTypes: true })) {
+    const entryPath = path19.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkMarkdownFiles(entryPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -13800,7 +14457,7 @@ function rewriteOptimaMarkdownReferences(content, evidenceBasePath = null) {
 }
 function optimaEvidenceBaseForFile(worktree, filePath, deps) {
   const evidenceRoot = deps.optimaEvidencesDir(worktree);
-  const relative = path16.relative(evidenceRoot, filePath).split(path16.sep).join("/");
+  const relative = path19.relative(evidenceRoot, filePath).split(path19.sep).join("/");
   const [taskId] = relative.split("/");
   if (!taskId || taskId === ".." || relative.startsWith("../")) return null;
   return `.optima/evidences/${taskId}`;
@@ -13813,11 +14470,11 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
   ];
   const changed = [];
   for (const filePath of scanRoots.flatMap(walkMarkdownFiles)) {
-    const raw = fs15.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path16.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
+    const raw = fs18.readFileSync(filePath, "utf8");
+    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path19.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
     const rewritten = rewriteOptimaMarkdownReferences(raw, evidenceBasePath);
     if (rewritten !== raw) {
-      fs15.writeFileSync(filePath, rewritten, "utf8");
+      fs18.writeFileSync(filePath, rewritten, "utf8");
       changed.push(relPath(worktree, filePath));
     }
   }
@@ -13825,8 +14482,8 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
 }
 function missingOptimaGitignoreRules(worktree, deps) {
   if (!deps.isGitRepository(worktree)) return [];
-  const gitignorePath = path16.join(worktree, ".gitignore");
-  const existing = fs15.existsSync(gitignorePath) ? fs15.readFileSync(gitignorePath, "utf8") : "";
+  const gitignorePath = path19.join(worktree, ".gitignore");
+  const existing = fs18.existsSync(gitignorePath) ? fs18.readFileSync(gitignorePath, "utf8") : "";
   const existingRules = new Set(existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
   return deps.optimaGitignoreRules.filter((rule) => !existingRules.has(rule));
 }
@@ -13843,11 +14500,11 @@ function planOptimaRepair(worktree, args = {}, deps) {
   const apply = mode === "apply";
   const actions = [];
   const unresolved = [];
-  const hadOptima = fs15.existsSync(deps.optimaDir(worktree));
+  const hadOptima = fs18.existsSync(deps.optimaDir(worktree));
   const missingGitignoreRules = missingOptimaGitignoreRules(worktree, deps);
   const markdownBefore = apply ? [] : walkMarkdownFiles(deps.optimaDir(worktree)).filter((filePath) => {
-    const raw = fs15.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path16.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
+    const raw = fs18.readFileSync(filePath, "utf8");
+    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path19.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
     return rewriteOptimaMarkdownReferences(raw, evidenceBasePath) !== raw;
   }).map((filePath) => relPath(worktree, filePath));
   if (!hadOptima) pushRepairAction(actions, "operational", apply ? "created" : "would_create", ".optima/", "Create Optima operational root.");
@@ -13856,31 +14513,31 @@ function planOptimaRepair(worktree, args = {}, deps) {
     [".staticeng/", deps.legacyStaticEngDir(worktree)],
     [".nomadwork/", deps.legacyNomadworkDir(worktree)],
     [".nomadworks/", deps.legacyNomadworksDir(worktree)],
-    ["tasks/", path16.join(worktree, "tasks")],
-    ["evidences/", path16.join(worktree, "evidences")],
-    ["docs/scrs/", path16.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path16.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path16.join(worktree, "codemap.yaml")]
+    ["tasks/", path19.join(worktree, "tasks")],
+    ["evidences/", path19.join(worktree, "evidences")],
+    ["docs/scrs/", path19.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path19.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path19.join(worktree, "codemap.yaml")]
   ];
-  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path16.join(worktree, "policies")]);
+  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path19.join(worktree, "policies")]);
   for (const [display, sourcePath] of legacySources) {
-    if (fs15.existsSync(sourcePath)) pushRepairAction(actions, "legacy", apply ? "migrated" : "would_migrate", display, "Move or merge legacy/root Optima artifact into .optima using preservation safeguards.");
+    if (fs18.existsSync(sourcePath)) pushRepairAction(actions, "legacy", apply ? "migrated" : "would_migrate", display, "Move or merge legacy/root Optima artifact into .optima using preservation safeguards.");
   }
   if (apply) deps.migrateLegacyOptimaLayout(worktree);
-  const configMissing = !fs15.existsSync(deps.repoConfigPath(worktree));
+  const configMissing = !fs18.existsSync(deps.repoConfigPath(worktree));
   if (configMissing) pushRepairAction(actions, "config", apply ? "created" : "would_create", ".optima/.config/optima.yaml", "Create missing local Optima config from template.");
   if (apply) deps.scaffoldOptimaConfig(worktree, args.team_mode || "full");
   const requiredFiles = [
-    [path16.join(deps.optimaTasksDir(worktree), "current.md"), "registry", ".optima/tasks/current.md", deps.currentTasksRegistryContent()],
-    [path16.join(deps.optimaTasksDir(worktree), "done.md"), "registry", ".optima/tasks/done.md", deps.doneTasksRegistryContent()],
-    [path16.join(deps.optimaScrsDir(worktree), "current.md"), "registry", ".optima/docs/scrs/current.md", deps.currentScrRegistryContent()],
-    [path16.join(deps.optimaScrsDir(worktree), "done.md"), "registry", ".optima/docs/scrs/done.md", deps.doneScrRegistryContent()],
-    [path16.join(deps.optimaTasksDir(worktree), "task-template.md"), "template", ".optima/tasks/task-template.md", deps.taskTemplateContent()],
-    [path16.join(deps.optimaTasksDir(worktree), "subtask-template.md"), "template", ".optima/tasks/subtask-template.md", deps.subtaskTemplateContent()],
-    [path16.join(deps.repoPoliciesDir(worktree), "README.md"), "policy", ".optima/policies/README.md", deps.repoLocalPoliciesReadme]
+    [path19.join(deps.optimaTasksDir(worktree), "current.md"), "registry", ".optima/tasks/current.md", deps.currentTasksRegistryContent()],
+    [path19.join(deps.optimaTasksDir(worktree), "done.md"), "registry", ".optima/tasks/done.md", deps.doneTasksRegistryContent()],
+    [path19.join(deps.optimaScrsDir(worktree), "current.md"), "registry", ".optima/docs/scrs/current.md", deps.currentScrRegistryContent()],
+    [path19.join(deps.optimaScrsDir(worktree), "done.md"), "registry", ".optima/docs/scrs/done.md", deps.doneScrRegistryContent()],
+    [path19.join(deps.optimaTasksDir(worktree), "task-template.md"), "template", ".optima/tasks/task-template.md", deps.taskTemplateContent()],
+    [path19.join(deps.optimaTasksDir(worktree), "subtask-template.md"), "template", ".optima/tasks/subtask-template.md", deps.subtaskTemplateContent()],
+    [path19.join(deps.repoPoliciesDir(worktree), "README.md"), "policy", ".optima/policies/README.md", deps.repoLocalPoliciesReadme]
   ];
   for (const [filePath, category, displayPath, content] of requiredFiles) {
-    if (!fs15.existsSync(filePath)) {
+    if (!fs18.existsSync(filePath)) {
       pushRepairAction(actions, category, apply ? "created" : "would_create", displayPath, "Create missing Optima scaffold file without overwriting existing content.");
       if (apply) deps.ensureFileIfMissing(filePath, content);
     }
@@ -13934,18 +14591,18 @@ function formatRepairResult(plan, validationResult = null, formatValidationResul
 // src/validate_logic.js
 var import_yaml5 = __toESM(require_dist(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import fs16 from "node:fs";
-import path17 from "node:path";
+import fs19 from "node:fs";
+import path20 from "node:path";
 async function optima_validate_logic(worktree) {
-  const rootCodemapPath = path17.join(worktree, ".optima", "codemap.yml");
-  if (!fs16.existsSync(rootCodemapPath)) return { ok: false, errors: [".optima/codemap.yml not found."], warnings: [] };
+  const rootCodemapPath = path20.join(worktree, ".optima", "codemap.yml");
+  if (!fs19.existsSync(rootCodemapPath)) return { ok: false, errors: [".optima/codemap.yml not found."], warnings: [] };
   const errors = [];
   const warnings = [];
   const ig = (0, import_ignore2.default)();
   ig.add(".git");
-  const gitignorePath = path17.join(worktree, ".gitignore");
-  if (fs16.existsSync(gitignorePath)) {
-    ig.add(fs16.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path20.join(worktree, ".gitignore");
+  if (fs19.existsSync(gitignorePath)) {
+    ig.add(fs19.readFileSync(gitignorePath, "utf8"));
   }
   const sourceExtensions = [
     ".js",
@@ -13985,30 +14642,30 @@ async function optima_validate_logic(worktree) {
   const operationalFolders = [".optima", "templates", "dist"];
   const isHiddenTree2 = (relPath2) => {
     if (!relPath2) return false;
-    return relPath2.split(path17.sep).some((part) => part.startsWith("."));
+    return relPath2.split(path20.sep).some((part) => part.startsWith("."));
   };
-  const firstPathSegment2 = (relPath2) => relPath2.split(path17.sep).filter(Boolean)[0] || "";
+  const firstPathSegment2 = (relPath2) => relPath2.split(path20.sep).filter(Boolean)[0] || "";
   const isOperationalRelPath2 = (relPath2) => {
     if (!relPath2) return false;
     const firstSegment = firstPathSegment2(relPath2);
     if (legacyOperationalRoots.has(firstSegment)) return true;
-    return operationalFolders.some((f) => relPath2 === f || relPath2.startsWith(f + path17.sep));
+    return operationalFolders.some((f) => relPath2 === f || relPath2.startsWith(f + path20.sep));
   };
   const getSectionEntries = (value) => {
     if (Array.isArray(value)) return value;
     if (value && typeof value === "object") return Object.values(value);
     return [];
   };
-  const normalizeRelativePath = (relPath2) => path17.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizeRelativePath = (relPath2) => path20.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
   const isSourceDir = (dirPath) => {
-    const dirRelPath = path17.relative(worktree, dirPath);
+    const dirRelPath = path20.relative(worktree, dirPath);
     if (isOperationalRelPath2(dirRelPath)) return false;
-    const items = fs16.readdirSync(dirPath, { withFileTypes: true });
+    const items = fs19.readdirSync(dirPath, { withFileTypes: true });
     for (const item of items) {
-      const childPath = path17.join(dirPath, item.name);
-      const relPath2 = path17.relative(worktree, childPath);
+      const childPath = path20.join(dirPath, item.name);
+      const relPath2 = path20.relative(worktree, childPath);
       if (ig.ignores(relPath2) || isOperationalRelPath2(relPath2)) continue;
-      if (item.isFile() && sourceExtensions.includes(path17.extname(item.name))) return true;
+      if (item.isFile() && sourceExtensions.includes(path20.extname(item.name))) return true;
       if (item.isDirectory()) {
         if (isSourceDir(childPath)) return true;
       }
@@ -14016,7 +14673,7 @@ async function optima_validate_logic(worktree) {
     return false;
   };
   function validateMap(filePath) {
-    const content = fs16.readFileSync(filePath, "utf8");
+    const content = fs19.readFileSync(filePath, "utf8");
     let map;
     try {
       map = import_yaml5.default.parse(content);
@@ -14028,32 +14685,32 @@ async function optima_validate_logic(worktree) {
       errors.push(`${filePath}: Invalid YAML.`);
       return;
     }
-    const dir = path17.dirname(filePath);
+    const dir = path20.dirname(filePath);
     const pathBase = filePath === rootCodemapPath ? worktree : dir;
     const indexedPaths = /* @__PURE__ */ new Set();
     const sectionsToVerify = ["modules", "entrypoints", "sources_of_truth", "links", "internals"];
     for (const section of sectionsToVerify) {
       for (const item of getSectionEntries(map[section])) {
         if (item?.path) {
-          indexedPaths.add(path17.normalize(item.path));
+          indexedPaths.add(path20.normalize(item.path));
           if (section === "links" && (item.path.startsWith("http://") || item.path.startsWith("https://"))) {
             continue;
           }
-          const absPath = path17.isAbsolute(item.path) ? item.path : path17.join(pathBase, item.path);
-          if (!fs16.existsSync(absPath)) {
+          const absPath = path20.isAbsolute(item.path) ? item.path : path20.join(pathBase, item.path);
+          if (!fs19.existsSync(absPath)) {
             errors.push(`${filePath}: ${section.slice(0, -1)} path does not exist: ${item.path}`);
           }
         }
       }
     }
-    const relDir = path17.relative(worktree, dir);
+    const relDir = path20.relative(worktree, dir);
     const isOperational = isOperationalRelPath2(relDir);
     if (map.scope === "module" && !isOperational) {
-      const items = fs16.readdirSync(dir, { withFileTypes: true });
+      const items = fs19.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (item.isFile() && sourceExtensions.includes(path17.extname(item.name))) {
+        if (item.isFile() && sourceExtensions.includes(path20.extname(item.name))) {
           if (item.name === "codemap.yml") continue;
-          if (!indexedPaths.has(path17.normalize(item.name))) {
+          if (!indexedPaths.has(path20.normalize(item.name))) {
             errors.push(`${filePath}: Unindexed source file found: '${item.name}'. Every source file must be categorized in a section (e.g., 'internals').`);
           }
         }
@@ -14063,7 +14720,7 @@ async function optima_validate_logic(worktree) {
     for (const key of pathKeys) {
       for (const entry of getSectionEntries(map[key])) {
         if (!entry?.path || entry.path.startsWith("http://") || entry.path.startsWith("https://")) continue;
-        if (path17.isAbsolute(entry.path)) continue;
+        if (path20.isAbsolute(entry.path)) continue;
         const normalizedPath = normalizeRelativePath(entry.path);
         if (!normalizedPath || normalizedPath === ".") continue;
         const parts = normalizedPath.split("/").filter((p) => p && p !== ".");
@@ -14075,18 +14732,18 @@ async function optima_validate_logic(worktree) {
     }
   }
   const walk = (dir) => {
-    const relDir = path17.relative(worktree, dir);
+    const relDir = path20.relative(worktree, dir);
     if (relDir && ig.ignores(relDir)) return;
     if (isOperationalRelPath2(relDir)) return;
     if (isHiddenTree2(relDir)) return;
-    const hasCodemap = fs16.existsSync(path17.join(dir, "codemap.yml"));
-    const items = fs16.readdirSync(dir, { withFileTypes: true });
-    if (!relDir.startsWith(path17.join(".optima", "tasks", "done"))) {
+    const hasCodemap = fs19.existsSync(path20.join(dir, "codemap.yml"));
+    const items = fs19.readdirSync(dir, { withFileTypes: true });
+    if (!relDir.startsWith(path20.join(".optima", "tasks", "done"))) {
       for (const item of items) {
         if (item.isFile() && item.name.endsWith(".md")) {
-          const content = fs16.readFileSync(path17.join(dir, item.name), "utf8");
+          const content = fs19.readFileSync(path20.join(dir, item.name), "utf8");
           if (content.includes("[To be defined]") || content.includes("[Insert ")) {
-            const relFilePath = path17.join(relDir, item.name);
+            const relFilePath = path20.join(relDir, item.name);
             errors.push(`Documentation Placeholder found: '${relFilePath}' still contains [To be defined] or [Insert ...] placeholders.`);
           }
         }
@@ -14096,9 +14753,9 @@ async function optima_validate_logic(worktree) {
     if (relDir !== "" && !hasCodemap && isSourceDir(dir) && !isOperational) {
       errors.push(`Missing CodeMap: Directory '${relDir}' contains source but has no codemap.yml.`);
     }
-    if (hasCodemap) validateMap(path17.join(dir, "codemap.yml"));
+    if (hasCodemap) validateMap(path20.join(dir, "codemap.yml"));
     for (const item of items) {
-      if (item.isDirectory()) walk(path17.join(dir, item.name));
+      if (item.isDirectory()) walk(path20.join(dir, item.name));
     }
   };
   validateMap(rootCodemapPath);
@@ -14112,12 +14769,13 @@ async function optima_validate_logic(worktree) {
 
 // src/plugin.js
 var activeWorkflows = /* @__PURE__ */ new Map();
+var activeQaQueueSchedulers = /* @__PURE__ */ new Map();
 function normalizeWorkflowTaskPath(taskPath) {
   if (typeof taskPath !== "string") return { ok: false, message: "Error: task_path is required." };
   const trimmed = taskPath.trim();
   if (!trimmed) return { ok: false, message: "Error: task_path is required." };
   const normalized = trimmed.replace(/\\/g, "/");
-  if (path18.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
+  if (path21.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
   if (normalized === "tasks" || normalized.startsWith("tasks/")) {
     return {
       ok: false,
@@ -14134,10 +14792,10 @@ function normalizeWorkflowTaskPath(taskPath) {
 }
 function readTaskMetadata(taskPath, worktree) {
   if (!taskPath) return {};
-  const absoluteTaskPath = path18.isAbsolute(taskPath) ? taskPath : path18.join(worktree, taskPath);
-  if (!fs17.existsSync(absoluteTaskPath)) return {};
+  const absoluteTaskPath = path21.isAbsolute(taskPath) ? taskPath : path21.join(worktree, taskPath);
+  if (!fs20.existsSync(absoluteTaskPath)) return {};
   try {
-    const raw = fs17.readFileSync(absoluteTaskPath, "utf8");
+    const raw = fs20.readFileSync(absoluteTaskPath, "utf8");
     const { data } = parseFrontmatter(raw);
     return {
       complexity: typeof data.complexity === "string" ? data.complexity.trim().toLowerCase() : void 0,
@@ -14160,15 +14818,15 @@ function hasActiveImplementationWorkflow() {
 function resolveSessionToolDirectory({ requestedDirectory, context, pluginWorktree, clickUpWebhookValidation } = {}) {
   const safe = safeWorktreeOrFailure(context, pluginWorktree);
   if (!safe.ok) return { ok: false, error: safe.message };
-  const requested = String(requestedDirectory || "").trim() ? path18.resolve(safe.worktree, String(requestedDirectory).trim()) : safe.worktree;
+  const requested = String(requestedDirectory || "").trim() ? path21.resolve(safe.worktree, String(requestedDirectory).trim()) : safe.worktree;
   if (!isSafeWritableDirectory(requested)) return { ok: false, error: `Directory is not a safe writable directory: ${requested}` };
   if (isSameOrNestedPath(requested, safe.worktree)) return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "context_worktree" };
   const clickUpBasePath = clickUpWebhookValidation?.complete === true && clickUpWebhookValidation?.ok !== false ? clickUpWebhookValidation.config?.basePath : "";
   if (clickUpBasePath && isSameOrNestedPath(requested, clickUpBasePath)) {
-    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path18.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path21.resolve(clickUpBasePath) };
   }
   if (clickUpBasePath && isClickUpDerivedWorktreeSibling(requested, clickUpBasePath)) {
-    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path18.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path21.resolve(clickUpBasePath) };
   }
   return {
     ok: false,
@@ -14183,9 +14841,9 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   const configPath = resolveConfigPath(worktree);
   const discussionRegistry = loadDiscussionRegistry(worktree);
   let repoCfg = { agents: {}, defaults: {}, features: {} };
-  if (fs17.existsSync(configPath)) {
+  if (fs20.existsSync(configPath)) {
     try {
-      repoCfg = import_yaml6.default.parse(fs17.readFileSync(configPath, "utf8")) || repoCfg;
+      repoCfg = import_yaml6.default.parse(fs20.readFileSync(configPath, "utf8")) || repoCfg;
     } catch (e) {
       console.error(`[Optima] Failed to parse config at ${configPath}:`, e);
     }
@@ -14346,6 +15004,134 @@ Evidencia: ${evidencePath}` : ""
       applied
     };
   };
+  const qaLeaseMs = Number(repoCfg.qa?.lease_ms || repoCfg.qa?.leaseMs || DEFAULT_QA_LEASE_MS) || DEFAULT_QA_LEASE_MS;
+  const qaProvider = String(repoCfg.qa?.provider || DEFAULT_QA_PROVIDER);
+  const qaCdpUrl = String(repoCfg.qa?.cdp_url || repoCfg.qa?.cdpUrl || process.env.OPTIMA_QA_CHROME_CDP_URL || "").trim();
+  const qaTaskMetadata = async (taskId) => {
+    if (!taskId || typeof runtimeClickUpClient?.getTask !== "function") return { task: null, metadata: {} };
+    const task = await runtimeClickUpClient.getTask(taskId);
+    const metadata = normalizeAgentMetadataJson(clickUpTaskAgentMetadata(task, clickUpWebhookValidation.config?.routing?.metadataFieldId));
+    return { task, metadata };
+  };
+  const qaSessionFromMetadata = (metadata = {}) => {
+    return metadata.optima?.sessions?.product_manager || metadata.task?.product_manager || metadata.sessions?.product_manager || "";
+  };
+  const qaWorktreeFromMetadata = (metadata = {}) => {
+    return metadata.task?.worktree || metadata.worktree || "";
+  };
+  const applyQaQueuedClickUpState = async (taskId) => {
+    const applied = [];
+    const errors = [];
+    const pmId = String(clickUpWebhookValidation.config?.routing?.productManagerAssigneeId || "").trim();
+    if (!taskId || !clickUpWebhookValidation.complete || !runtimeClickUpClient) return { applied, errors };
+    if (runtimeClickUpClient.updateTaskStatus) {
+      try {
+        await runtimeClickUpClient.updateTaskStatus({ taskId, status: "waiting QA slot" });
+        applied.push("status:waiting QA slot");
+      } catch (error) {
+        errors.push(`status:${error.message}`);
+      }
+    }
+    if (pmId && runtimeClickUpClient.updateTaskAssignees) {
+      try {
+        await runtimeClickUpClient.updateTaskAssignees({ taskId, remove: [pmId] });
+        applied.push("remove_product_manager");
+      } catch (error) {
+        errors.push(`assignees:${error.message}`);
+      }
+    }
+    return { applied, errors };
+  };
+  const wakePromotedQaTask = async (entry, { provider = qaProvider, reason = "qa_slot_available" } = {}) => {
+    const taskId = String(entry?.clickupTaskId || "").trim();
+    const applied = [];
+    const errors = [];
+    if (!taskId || !clickUpWebhookValidation.complete) return { ok: false, reason: "missing_task_or_clickup_config" };
+    const pmId = String(clickUpWebhookValidation.config?.routing?.productManagerAssigneeId || "").trim();
+    const humanIds = Object.values(clickUpWebhookValidation.config?.routing?.humanRoleClickUpIds || {}).map((id) => String(id || "").trim()).filter(Boolean);
+    try {
+      if (runtimeClickUpClient.updateTaskStatus) {
+        await runtimeClickUpClient.updateTaskStatus({ taskId, status: "in progress" });
+        applied.push("status:in progress");
+      }
+    } catch (error) {
+      errors.push(`status:${error.message}`);
+    }
+    try {
+      if (pmId && runtimeClickUpClient.updateTaskAssignees) {
+        await runtimeClickUpClient.updateTaskAssignees({ taskId, add: [pmId], remove: humanIds });
+        applied.push("assign_product_manager");
+      }
+    } catch (error) {
+      errors.push(`assignees:${error.message}`);
+    }
+    let metadata = {};
+    try {
+      metadata = (await qaTaskMetadata(taskId)).metadata;
+    } catch (error) {
+      errors.push(`metadata:${error.message}`);
+    }
+    const sessionId = entry.sessionId || qaSessionFromMetadata(metadata);
+    const directory = entry.worktree || qaWorktreeFromMetadata(metadata);
+    if (sessionId && input.client && typeof sendOpenCodeSessionEvent === "function") {
+      try {
+        const prompt = [
+          `[Optima QA Slot Granted]`,
+          `Provider: ${provider}`,
+          `ClickUp task: ${taskId}`,
+          `Reason: ${reason}`,
+          "",
+          "Ya tienes plaza exclusiva para usar el Chrome QA. Debes llamar a `optima_qa_chrome_command` en menos de 5 minutos para conservar la plaza.",
+          "Puedes conservarla mientras hagas al menos una llamada QA cada 5 minutos.",
+          "Cuando termines, llama obligatoriamente a `optima_qa_finish` para resetear la extensi\xF3n y liberar la cola.",
+          "La pesta\xF1a 0 es intocable: usa \xFAnicamente la pesta\xF1a QA que Optima crea para esta tarea."
+        ].join("\n");
+        await sendOpenCodeSessionEvent(input.client, {
+          sessionId,
+          agent: clickUpWebhookValidation.config.routing?.targetAgent || "workflow_product_manager",
+          text: prompt,
+          directory,
+          opencodeBaseUrl: clickUpWebhookValidation.config.opencode?.baseUrl,
+          fetchImpl: input.fetch,
+          directDelivery: "steer"
+        });
+        applied.push("session_prompt");
+      } catch (error) {
+        errors.push(`session_prompt:${error.message}`);
+      }
+    } else {
+      errors.push("session_prompt:missing_session_or_client");
+    }
+    return { ok: errors.length === 0, taskId, sessionId, directory, applied, errors };
+  };
+  const persistQaState = async (provider, state, transitions = {}) => {
+    const written = writeQaQueueState(state, qaQueueStatePath(provider));
+    const notifications = [];
+    const promoted = transitions.promoted || null;
+    if (promoted?.clickupTaskId) notifications.push(await wakePromotedQaTask(promoted, { provider, reason: transitions.reason || "qa_slot_available" }));
+    return { state: written, notifications };
+  };
+  const scheduleQaQueueReaper = () => {
+    if (input.startQaQueueScheduler === false) return;
+    const provider = qaProvider || DEFAULT_QA_PROVIDER;
+    const schedulerKey = `${provider}:${clickUpWebhookValidation.config?.basePath || worktree}`;
+    if (activeQaQueueSchedulers.has(schedulerKey)) return;
+    const interval = setInterval(async () => {
+      try {
+        const statePath = qaQueueStatePath(provider);
+        const current = readQaQueueState(provider, statePath);
+        const result = releaseExpiredQaSlot(current, { leaseMs: qaLeaseMs });
+        if (result.expired || result.promoted) {
+          await persistQaState(provider, result.state, { promoted: result.promoted, reason: result.expired ? "previous_slot_expired" : "qa_slot_available" });
+        }
+      } catch (error) {
+        appendClickUpWebhookLocalLog(worktree, { type: "qa_queue_reaper_failed", provider, message: error.message });
+      }
+    }, Math.min(6e4, Math.max(1e4, Math.floor(qaLeaseMs / 5))));
+    interval.unref?.();
+    activeQaQueueSchedulers.set(schedulerKey, interval);
+  };
+  scheduleQaQueueReaper();
   const tools = {
     optima_init: tool({
       description: "Initialize the Optima workflow and CodeMap in the current repository",
@@ -14362,10 +15148,10 @@ Evidencia: ${evidencePath}` : ""
         }
         migrateLegacyOptimaLayout(toolWorktree);
         const cfgDir = optimaConfigDir(toolWorktree);
-        if (!fs17.existsSync(cfgDir)) fs17.mkdirSync(cfgDir, { recursive: true });
-        const optimaTmplPath = path18.join(TEMPLATES_DIR, "optima.yaml.template");
-        const codemapTmplPath = path18.join(TEMPLATES_DIR, "codemap.yml.template");
-        if (!fs17.existsSync(optimaTmplPath) || !fs17.existsSync(codemapTmplPath)) {
+        if (!fs20.existsSync(cfgDir)) fs20.mkdirSync(cfgDir, { recursive: true });
+        const optimaTmplPath = path21.join(TEMPLATES_DIR, "optima.yaml.template");
+        const codemapTmplPath = path21.join(TEMPLATES_DIR, "codemap.yml.template");
+        if (!fs20.existsSync(optimaTmplPath) || !fs20.existsSync(codemapTmplPath)) {
           return "Error: Initialization templates not found in plugin.";
         }
         scaffoldOptimaConfig(toolWorktree, requestedTeamMode);
@@ -14486,14 +15272,14 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
       async execute(args, context) {
         const safe = safeWorktreeOrFailure(context, worktree);
         if (!safe.ok) return safe.message;
-        const summaryPath = path18.resolve(safe.worktree, args.summary_path || "");
-        if (!fs17.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
-        const taskPath = args.task_path ? path18.resolve(safe.worktree, args.task_path) : "";
+        const summaryPath = path21.resolve(safe.worktree, args.summary_path || "");
+        if (!fs20.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
+        const taskPath = args.task_path ? path21.resolve(safe.worktree, args.task_path) : "";
         const payload = buildClickUpSummaryPayload({
-          summaryMarkdown: fs17.readFileSync(summaryPath, "utf8"),
-          summaryPath: path18.relative(safe.worktree, summaryPath),
-          taskMarkdown: taskPath && fs17.existsSync(taskPath) ? fs17.readFileSync(taskPath, "utf8") : "",
-          taskPath: taskPath ? path18.relative(safe.worktree, taskPath) : "",
+          summaryMarkdown: fs20.readFileSync(summaryPath, "utf8"),
+          summaryPath: path21.relative(safe.worktree, summaryPath),
+          taskMarkdown: taskPath && fs20.existsSync(taskPath) ? fs20.readFileSync(taskPath, "utf8") : "",
+          taskPath: taskPath ? path21.relative(safe.worktree, taskPath) : "",
           branch: args.branch,
           worktree: args.worktree,
           pr: args.pr
@@ -14586,6 +15372,116 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
         }
       }
     }),
+    optima_qa_browser_status: tool({
+      description: "Inspect the shared Optima QA browser and queue state for a provider such as chatgpt.",
+      args: {
+        provider: tool.schema.string().optional().describe("QA provider. Defaults to chatgpt."),
+        clickup_task_id: tool.schema.string().optional().describe("Optional ClickUp task id to identify its QA tab."),
+        cdp_url: tool.schema.string().optional().describe("Optional Chrome DevTools URL. Defaults to configured QA URL or http://127.0.0.1:9222.")
+      },
+      async execute(args = {}) {
+        const provider = String(args.provider || qaProvider || DEFAULT_QA_PROVIDER);
+        const state = readQaQueueState(provider);
+        const browser = await qaBrowserStatus({ provider, cdpUrl: args.cdp_url || qaCdpUrl, clickupTaskId: args.clickup_task_id || "" });
+        return JSON.stringify({ ok: browser.ok !== false, provider, leaseMs: qaLeaseMs, queue: state, browser }, null, 2);
+      }
+    }),
+    optima_qa_request_slot: tool({
+      description: "Request the exclusive QA browser slot for a ClickUp task. If busy, Optima queues the task, marks it waiting QA slot, and removes Product Manager assignment.",
+      args: {
+        clickup_task_id: tool.schema.string().describe("ClickUp task id requesting the QA slot"),
+        provider: tool.schema.string().optional().describe("QA provider. Defaults to chatgpt."),
+        session_id: tool.schema.string().optional().describe("Optional OpenCode session id to wake when the slot is granted later"),
+        worktree: tool.schema.string().optional().describe("Optional task worktree/directory for session wakeups"),
+        reason: tool.schema.string().optional().describe("Short reason/scenario for requesting the QA slot")
+      },
+      async execute(args = {}) {
+        const provider = String(args.provider || qaProvider || DEFAULT_QA_PROVIDER);
+        const pathToState = qaQueueStatePath(provider);
+        const current = readQaQueueState(provider, pathToState);
+        const result = requestQaSlot(current, {
+          clickupTaskId: args.clickup_task_id,
+          sessionId: args.session_id,
+          worktree: args.worktree,
+          reason: args.reason,
+          leaseMs: qaLeaseMs
+        });
+        let queuedClickUp = null;
+        if (result.action === "queued") queuedClickUp = await applyQaQueuedClickUpState(args.clickup_task_id);
+        const persisted = await persistQaState(provider, result.state, { promoted: result.promoted, reason: result.expired ? "previous_slot_expired" : "qa_slot_available" });
+        const guidance = result.ok ? "QA slot granted. Use optima_qa_chrome_command within 5 minutes and then at least once every 5 minutes. Use optima_qa_finish when done." : "QA slot busy. Task has been queued; stop work on QA, wait for Optima to reassign/wake the session when your slot is granted.";
+        return JSON.stringify({ ...result, state: persisted.state, notifications: persisted.notifications, queuedClickUp, guidance }, null, 2);
+      }
+    }),
+    optima_qa_chrome_command: tool({
+      description: "Run one flexible Playwright/CDP command against the shared QA Chrome for the active ClickUp task. The persistent tab 0 is never used; Optima creates/reuses a task QA tab.",
+      args: {
+        clickup_task_id: tool.schema.string().describe("ClickUp task id that currently owns the QA slot"),
+        provider: tool.schema.string().optional().describe("QA provider. Defaults to chatgpt."),
+        command_json: tool.schema.string().describe("JSON command object, or raw async JS script. Actions: status, goto, evaluate, screenshot, set_input_files, script."),
+        cdp_url: tool.schema.string().optional().describe("Optional Chrome DevTools URL"),
+        start_url: tool.schema.string().optional().describe("Initial URL for a new QA tab. Defaults to https://chatgpt.com/")
+      },
+      async execute(args = {}) {
+        const provider = String(args.provider || qaProvider || DEFAULT_QA_PROVIDER);
+        const pathToState = qaQueueStatePath(provider);
+        const current = readQaQueueState(provider, pathToState);
+        const touched = touchQaSlot(current, { clickupTaskId: args.clickup_task_id, leaseMs: qaLeaseMs });
+        const persisted = await persistQaState(provider, touched.state, { promoted: touched.promoted, reason: touched.expired ? "previous_slot_expired" : "qa_slot_available" });
+        if (!touched.ok) {
+          return JSON.stringify({
+            ok: false,
+            action: touched.action,
+            active: persisted.state.active,
+            queue: persisted.state.queue,
+            notifications: persisted.notifications,
+            guidance: "You do not own the QA slot. Call optima_qa_request_slot and stop if queued."
+          }, null, 2);
+        }
+        try {
+          const result = await qaRunChromeCommand({
+            provider,
+            cdpUrl: args.cdp_url || qaCdpUrl,
+            clickupTaskId: args.clickup_task_id,
+            commandJson: args.command_json,
+            startUrl: args.start_url || "https://chatgpt.com/"
+          });
+          return JSON.stringify({ ok: result.ok !== false, lease: persisted.state.active, notifications: persisted.notifications, chrome: result }, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message, lease: persisted.state.active, notifications: persisted.notifications }, null, 2);
+        }
+      }
+    }),
+    optima_qa_finish: tool({
+      description: "Finish the active QA browser slot, reset/reload the extension, release the slot, and wake the next queued ClickUp task if any.",
+      args: {
+        clickup_task_id: tool.schema.string().describe("ClickUp task id finishing QA"),
+        provider: tool.schema.string().optional().describe("QA provider. Defaults to chatgpt."),
+        cdp_url: tool.schema.string().optional().describe("Optional Chrome DevTools URL"),
+        extension_path: tool.schema.string().optional().describe("Optional extension path to sync into the stable QA extension-under-test directory before reset/reload"),
+        extension_id: tool.schema.string().optional().describe("Optional Chrome extension id when multiple extension service workers exist"),
+        reset_extension: tool.schema.boolean().optional().describe("Defaults true. Clear extension storage/caches/IndexedDB."),
+        reload_extension: tool.schema.boolean().optional().describe("Defaults true. Reload the extension service worker after reset.")
+      },
+      async execute(args = {}) {
+        const provider = String(args.provider || qaProvider || DEFAULT_QA_PROVIDER);
+        const reset = args.reset_extension !== false;
+        const reload = args.reload_extension !== false;
+        const extension = await qaPrepareExtension({
+          provider,
+          cdpUrl: args.cdp_url || qaCdpUrl,
+          extensionPath: args.extension_path || "",
+          extensionId: args.extension_id || "",
+          reset,
+          reload
+        }).catch((error) => ({ ok: false, error: error.message }));
+        const pathToState = qaQueueStatePath(provider);
+        const current = readQaQueueState(provider, pathToState);
+        const result = finishQaSlot(current, { clickupTaskId: args.clickup_task_id, leaseMs: qaLeaseMs });
+        const persisted = await persistQaState(provider, result.state, { promoted: result.promoted, reason: "previous_finished" });
+        return JSON.stringify({ ...result, state: persisted.state, notifications: persisted.notifications, extension }, null, 2);
+      }
+    }),
     optima_clickup_create_subtasks: tool({
       description: "Generate dry-run ClickUp subtask creation payloads from a strict Markdown ## Subtasks section",
       args: {
@@ -14598,12 +15494,12 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
       async execute(args, context) {
         const safe = safeWorktreeOrFailure(context, worktree);
         if (!safe.ok) return safe.message;
-        const markdownPath = path18.resolve(safe.worktree, args.markdown_path || "");
-        if (!fs17.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
+        const markdownPath = path21.resolve(safe.worktree, args.markdown_path || "");
+        if (!fs20.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
         const payload = buildClickUpCreateSubtasksPayload({
           parentTaskId: args.parent_task_id,
-          markdown: fs17.readFileSync(markdownPath, "utf8"),
-          sourcePath: path18.relative(safe.worktree, markdownPath),
+          markdown: fs20.readFileSync(markdownPath, "utf8"),
+          sourcePath: path21.relative(safe.worktree, markdownPath),
           parentBranch: args.parent_branch,
           parentTaskType: args.parent_task_type || "Tarea",
           apply: String(args.apply || "").toLowerCase() === "true"
@@ -14973,7 +15869,7 @@ Backfilled messages: ${backfilled}`;
         if (!existing) {
           return "FAIL: No active discussion exists for this session.";
         }
-        const discussionPath = path18.join(toolWorktree, existing.transcriptPath);
+        const discussionPath = path21.join(toolWorktree, existing.transcriptPath);
         setDiscussionStatus(discussionPath, "summarizing");
         existing.status = "summarizing";
         saveDiscussionRegistry(toolWorktree, toolRegistry);
@@ -15025,7 +15921,7 @@ Reason: ${err.message}`;
         try {
           const sessionResult = await client.session.create({
             query: { directory: workflowDirectory },
-            body: { title: `Workflow Run: ${path18.basename(workflowTaskPath)}` }
+            body: { title: `Workflow Run: ${path21.basename(workflowTaskPath)}` }
           });
           const sessionId = sessionResult.data.id;
           activeWorkflows.set(sessionId, { pmaSessionId, taskPath: workflowTaskPath, track: workflowTrack, directory: workflowDirectory });
@@ -15209,14 +16105,14 @@ function usage() {
   ].join("\n");
 }
 function expandHome(inputPath) {
-  if (!inputPath || inputPath === "~") return os5.homedir();
-  if (inputPath.startsWith("~/")) return path19.join(os5.homedir(), inputPath.slice(2));
+  if (!inputPath || inputPath === "~") return os7.homedir();
+  if (inputPath.startsWith("~/")) return path22.join(os7.homedir(), inputPath.slice(2));
   return inputPath;
 }
 function resolveOpenCodeDbPath(inputPath = null) {
   const expanded = expandHome(inputPath || process.env.OPTIMA_OPENCODE_DB_PATH || DEFAULT_DB_PATH);
   try {
-    if (fs18.existsSync(expanded) && fs18.statSync(expanded).isDirectory()) return path19.join(expanded, "opencode.db");
+    if (fs21.existsSync(expanded) && fs21.statSync(expanded).isDirectory()) return path22.join(expanded, "opencode.db");
   } catch {
     return expanded;
   }
@@ -15280,12 +16176,12 @@ function extractOpenedPathValue(value) {
 }
 function normalizePathCandidate(candidate) {
   const expanded = expandHome(candidate);
-  if (!path19.isAbsolute(expanded)) return null;
-  return path19.resolve(expanded);
+  if (!path22.isAbsolute(expanded)) return null;
+  return path22.resolve(expanded);
 }
 function discoverOpenCodePaths(dbPath) {
   const resolvedDb = resolveOpenCodeDbPath(dbPath);
-  if (!fs18.existsSync(resolvedDb)) throw new Error(`OpenCode database not found: ${resolvedDb}`);
+  if (!fs21.existsSync(resolvedDb)) throw new Error(`OpenCode database not found: ${resolvedDb}`);
   const tables = sqliteJson(resolvedDb, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name");
   const discovered = /* @__PURE__ */ new Set();
   for (const table of tables) {
@@ -15310,27 +16206,27 @@ function discoverOpenCodePaths(dbPath) {
 function collectMarkdownOverridesFrom(baseDir) {
   const files = [];
   for (const dirName of OVERRIDE_DIRS) {
-    const dirPath = path19.join(baseDir, dirName);
-    if (!fs18.existsSync(dirPath)) continue;
-    for (const entry of fs18.readdirSync(dirPath, { withFileTypes: true })) {
+    const dirPath = path22.join(baseDir, dirName);
+    if (!fs21.existsSync(dirPath)) continue;
+    for (const entry of fs21.readdirSync(dirPath, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".md")) continue;
       if (entry.name.toLowerCase() === "readme.md") continue;
-      files.push(path19.join(dirPath, entry.name));
+      files.push(path22.join(dirPath, entry.name));
     }
   }
   return files;
 }
 function collectOverrideFiles(worktree) {
-  return collectMarkdownOverridesFrom(path19.join(worktree, ".optima")).sort();
+  return collectMarkdownOverridesFrom(path22.join(worktree, ".optima")).sort();
 }
 function collectPlannedOverrideFiles(worktree) {
   return [
     ...collectOverrideFiles(worktree),
-    ...collectMarkdownOverridesFrom(path19.join(worktree, ".staticeng")),
-    ...collectMarkdownOverridesFrom(path19.join(worktree, ".orbita")),
-    ...collectMarkdownOverridesFrom(path19.join(worktree, ".nomadwork")),
-    ...collectMarkdownOverridesFrom(path19.join(worktree, ".nomadworks"))
+    ...collectMarkdownOverridesFrom(path22.join(worktree, ".staticeng")),
+    ...collectMarkdownOverridesFrom(path22.join(worktree, ".orbita")),
+    ...collectMarkdownOverridesFrom(path22.join(worktree, ".nomadwork")),
+    ...collectMarkdownOverridesFrom(path22.join(worktree, ".nomadworks"))
   ].sort();
 }
 var CRC_TABLE = (() => {
@@ -15363,14 +16259,14 @@ function writeUInt16LE(value) {
   return buffer;
 }
 function createZipBackup(files, backupPath) {
-  fs18.mkdirSync(path19.dirname(backupPath), { recursive: true });
+  fs21.mkdirSync(path22.dirname(backupPath), { recursive: true });
   const localParts = [];
   const centralParts = [];
   let offset = 0;
   const now = dosTimeDate();
   for (const filePath of files) {
-    const data = fs18.readFileSync(filePath);
-    const name = path19.resolve(filePath).replace(/^\//, "").split(path19.sep).join("/");
+    const data = fs21.readFileSync(filePath);
+    const name = path22.resolve(filePath).replace(/^\//, "").split(path22.sep).join("/");
     const nameBuffer = Buffer.from(name, "utf8");
     const crc = crc32(data);
     const local = Buffer.concat([
@@ -15422,7 +16318,7 @@ function createZipBackup(files, backupPath) {
     writeUInt32LE(offset),
     writeUInt16LE(0)
   ]);
-  fs18.writeFileSync(backupPath, Buffer.concat([...localParts, ...centralParts, end]));
+  fs21.writeFileSync(backupPath, Buffer.concat([...localParts, ...centralParts, end]));
 }
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
@@ -15432,17 +16328,17 @@ function validationStatus(result) {
   return result.ok ? "passed" : "failed";
 }
 function hasLegacyMarker(worktree) {
-  return fs18.existsSync(path19.join(worktree, ".staticeng")) || fs18.existsSync(path19.join(worktree, ".orbita")) || fs18.existsSync(path19.join(worktree, ".nomadwork")) || fs18.existsSync(path19.join(worktree, ".nomadworks"));
+  return fs21.existsSync(path22.join(worktree, ".staticeng")) || fs21.existsSync(path22.join(worktree, ".orbita")) || fs21.existsSync(path22.join(worktree, ".nomadwork")) || fs21.existsSync(path22.join(worktree, ".nomadworks"));
 }
 function rootOptimaArtifacts(worktree) {
   const artifacts = [
-    ["tasks/", path19.join(worktree, "tasks")],
-    ["evidences/", path19.join(worktree, "evidences")],
-    ["docs/scrs/", path19.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path19.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path19.join(worktree, "codemap.yaml")]
+    ["tasks/", path22.join(worktree, "tasks")],
+    ["evidences/", path22.join(worktree, "evidences")],
+    ["docs/scrs/", path22.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path22.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path22.join(worktree, "codemap.yaml")]
   ];
-  return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs18.existsSync(item.path));
+  return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs21.existsSync(item.path));
 }
 function hasSanitizableOverrides(worktree) {
   return collectPlannedOverrideFiles(worktree).length > 0;
@@ -15468,7 +16364,7 @@ function planOptimaMigration(worktree, dryRun) {
       ...overrides.map((file) => ({
         category: "override",
         action: dryRun ? "would_remove_after_backup" : "removed_after_backup",
-        path: path19.relative(worktree, file).split(path19.sep).join("/"),
+        path: path22.relative(worktree, file).split(path22.sep).join("/"),
         detail: "Remove implicit agent/policy override after host-level backup."
       }))
     ],
@@ -15489,12 +16385,12 @@ async function sanitizeHost(options = {}) {
   const repoStates = [];
   for (const candidate of paths) {
     try {
-      if (!fs18.existsSync(candidate)) {
+      if (!fs21.existsSync(candidate)) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "missing" });
         continue;
       }
-      if (!fs18.statSync(candidate).isDirectory()) {
+      if (!fs21.statSync(candidate).isDirectory()) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "not_directory" });
         continue;
@@ -15516,7 +16412,7 @@ async function sanitizeHost(options = {}) {
   const overrides = repoStates.flatMap((state) => state.overrideFiles.map((file) => ({ repo: state.repo, file })));
   report.totals.overrideFiles = overrides.length;
   if (!dryRun && overrides.length > 0) {
-    const backupPath = path19.join(os5.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
+    const backupPath = path22.join(os7.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
     try {
       createZipBackup(overrides.map((item) => item.file), backupPath);
       report.backupPath = backupPath;
@@ -15532,7 +16428,7 @@ async function sanitizeHost(options = {}) {
   for (const state of repoStates) {
     try {
       if (!dryRun) {
-        for (const file of state.overrideFiles) fs18.rmSync(file, { force: true });
+        for (const file of state.overrideFiles) fs21.rmSync(file, { force: true });
       }
       const validation = !dryRun && hasLegacyMarker(state.repo) ? await optima_validate_logic(state.repo) : null;
       const status = (!validation || validation.ok) && state.plan.unresolved.length === 0 ? "repaired" : "failed";
@@ -15545,7 +16441,7 @@ async function sanitizeHost(options = {}) {
         repairActions: state.plan.actions.length,
         repairSkipped: state.plan.skippedRepair === true,
         overrideFiles: state.overrideFiles.length,
-        overridePaths: state.overrideFiles.map((file) => path19.relative(state.repo, file).split(path19.sep).join("/")),
+        overridePaths: state.overrideFiles.map((file) => path22.relative(state.repo, file).split(path22.sep).join("/")),
         validation: validation ? validationStatus(validation) : "skipped",
         unresolved: state.plan.unresolved
       });