@defend-tech/opencode-optima 0.1.84 → 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, path22) {
-      const ctrl = callVisitor(key, node, visitor, path22);
+    function visit_(key, node, visitor, path23) {
+      const ctrl = callVisitor(key, node, visitor, path23);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path22, ctrl);
-        return visit_(key, ctrl, visitor, path22);
+        replaceNode(key, path23, ctrl);
+        return visit_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path22 = Object.freeze(path22.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, path22);
+            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)) {
-          path22 = Object.freeze(path22.concat(node));
-          const ck = visit_("key", node.key, visitor, path22);
+          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, path22);
+          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, path22) {
-      const ctrl = await callVisitor(key, node, visitor, path22);
+    async function visitAsync_(key, node, visitor, path23) {
+      const ctrl = await callVisitor(key, node, visitor, path23);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path22, ctrl);
-        return visitAsync_(key, ctrl, visitor, path22);
+        replaceNode(key, path23, ctrl);
+        return visitAsync_(key, ctrl, visitor, path23);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path22 = Object.freeze(path22.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, path22);
+            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)) {
-          path22 = Object.freeze(path22.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path22);
+          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, path22);
+          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, path22) {
+    function callVisitor(key, node, visitor, path23) {
       if (typeof visitor === "function")
-        return visitor(key, node, path22);
+        return visitor(key, node, path23);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path22);
+        return visitor.Map?.(key, node, path23);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path22);
+        return visitor.Seq?.(key, node, path23);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path22);
+        return visitor.Pair?.(key, node, path23);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path22);
+        return visitor.Scalar?.(key, node, path23);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path22);
+        return visitor.Alias?.(key, node, path23);
       return void 0;
     }
-    function replaceNode(key, path22, node) {
-      const parent = path22[path22.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, path22, value) {
+    function collectionFromPath(schema, path23, value) {
       let v = value;
-      for (let i = path22.length - 1; i >= 0; --i) {
-        const k = path22[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 = (path22) => path22 == null || typeof path22 === "object" && !!path22[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(path22, value) {
-        if (isEmptyPath(path22))
+      addIn(path23, value) {
+        if (isEmptyPath(path23))
           this.add(value);
         else {
-          const [key, ...rest] = path22;
+          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(path22) {
-        const [key, ...rest] = path22;
+      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(path22, keepScalar) {
-        const [key, ...rest] = path22;
+      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(path22) {
-        const [key, ...rest] = path22;
+      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(path22, value) {
-        const [key, ...rest] = path22;
+      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(path22, value) {
+      addIn(path23, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path22, 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(path22) {
-        if (Collection.isEmptyPath(path22)) {
+      deleteIn(path23) {
+        if (Collection.isEmptyPath(path23)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path22) : 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(path22, keepScalar) {
-        if (Collection.isEmptyPath(path22))
+      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(path22, 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(path22) {
-        if (Collection.isEmptyPath(path22))
+      hasIn(path23) {
+        if (Collection.isEmptyPath(path23))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path22) : 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(path22, value) {
-        if (Collection.isEmptyPath(path22)) {
+      setIn(path23, value) {
+        if (Collection.isEmptyPath(path23)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path22), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path23), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path22, 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, path22) => {
+    visit.itemAtPath = (cst, path23) => {
       let item = cst;
-      for (const [field, index] of path22) {
+      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, path22) => {
-      const parent = visit.itemAtPath(cst, path22.slice(0, -1));
-      const field = path22[path22.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(path22, item, visitor) {
-      let ctrl = visitor(item, path22);
+    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(path22.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, path22);
+            ctrl = ctrl(item, path23);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path22) : 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 fs21 = this.flowScalar(this.type);
+              const fs22 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs21, sep: [] });
+                map.items.push({ start, key: fs22, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs21);
+                this.stack.push(fs22);
               } else {
-                Object.assign(it, { key: fs21, 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 fs21 = this.flowScalar(this.type);
+              const fs22 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs21, sep: [] });
+                fc.items.push({ start: [], key: fs22, sep: [] });
               else if (it.sep)
-                this.stack.push(fs21);
+                this.stack.push(fs22);
               else
-                Object.assign(it, { key: fs21, 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 = (path22, originalPath, doThrow) => {
-      if (!isString(path22)) {
+    var checkPath = (path23, originalPath, doThrow) => {
+      if (!isString(path23)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path22) {
+      if (!path23) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path22)) {
+      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 = (path22) => REGEX_TEST_INVALID_PATH.test(path22);
+    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(path22, 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(path22);
+          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 path22 = originalPath && checkPath.convert(originalPath);
+        const path23 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path22,
+          path23,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path22, cache, checkUnignored, slices);
+        return this._t(path23, cache, checkUnignored, slices);
       }
-      _t(path22, cache, checkUnignored, slices) {
-        if (path22 in cache) {
-          return cache[path22];
+      _t(path23, cache, checkUnignored, slices) {
+        if (path23 in cache) {
+          return cache[path23];
         }
         if (!slices) {
-          slices = path22.split(SLASH);
+          slices = path23.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path22] = this._testOne(path22, 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[path22] = parent.ignored ? parent : this._testOne(path22, checkUnignored);
+        return cache[path23] = parent.ignored ? parent : this._testOne(path23, checkUnignored);
       }
-      ignores(path22) {
-        return this._test(path22, this._ignoreCache, false).ignored;
+      ignores(path23) {
+        return this._test(path23, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path22) => !this.ignores(path22);
+        return (path23) => !this.ignores(path23);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path22) {
-        return this._test(path22, this._testCache, true);
+      test(path23) {
+        return this._test(path23, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path22) => checkPath(path22 && checkPath.convert(path22), path22, 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 = (path22) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path22) || isNotRelative(path22);
+      checkPath.isNotRelative = (path23) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path23) || isNotRelative(path23);
     }
   }
 });
 
 // src/sanitize_cli.js
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os7 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 
 // src/plugin.js
-import fs19 from "node:fs";
+import fs20 from "node:fs";
 var import_yaml6 = __toESM(require_dist(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import path20 from "node:path";
+import path21 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/agents.js
@@ -13507,28 +13507,285 @@ function createGitHubApiClient(config = {}, fetchImpl = globalThis.fetch) {
 }
 
 // src/qa/chrome.js
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 import os6 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 
-// src/qa/queue.js
+// src/qa/cdp.js
 import fs15 from "node:fs";
-import os5 from "node:os";
 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 && path16.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path16.join(os5.homedir(), ".local", "share", "opencode");
+  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 path16.join(dataHome(), "opencode-optima", "qa");
+  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 path16.join(qaRuntimeDir(), `${normalizeQaProvider(provider)}-queue.json`);
+  return path17.join(qaRuntimeDir(), `${normalizeQaProvider(provider)}-queue.json`);
 }
 function nowIso(now = /* @__PURE__ */ new Date()) {
   return now instanceof Date ? now.toISOString() : new Date(now).toISOString();
@@ -13546,7 +13803,7 @@ function emptyQaQueueState(provider = DEFAULT_QA_PROVIDER) {
 }
 function readQaQueueState(provider = DEFAULT_QA_PROVIDER, statePath = qaQueueStatePath(provider)) {
   try {
-    const raw = fs15.readFileSync(statePath, "utf8");
+    const raw = fs16.readFileSync(statePath, "utf8");
     const parsed = JSON.parse(raw);
     if (!isPlainObject(parsed)) return emptyQaQueueState(provider);
     return {
@@ -13568,8 +13825,8 @@ function writeQaQueueState(state, statePath = qaQueueStatePath(state?.provider))
     queue: Array.isArray(state?.queue) ? state.queue.filter(isPlainObject) : [],
     history: Array.isArray(state?.history) ? state.history.filter(isPlainObject).slice(-50) : []
   };
-  fs15.mkdirSync(path16.dirname(statePath), { recursive: true });
-  fs15.writeFileSync(statePath, `${JSON.stringify(normalized, null, 2)}
+  fs16.mkdirSync(path17.dirname(statePath), { recursive: true });
+  fs16.writeFileSync(statePath, `${JSON.stringify(normalized, null, 2)}
 `, { mode: 384 });
   return normalized;
 }
@@ -13676,14 +13933,15 @@ function finishQaSlot(state, { clickupTaskId, now = /* @__PURE__ */ new Date(),
 
 // 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 path17.join(qaRuntimeDir(), normalizeQaProvider(provider));
+  return path18.join(qaRuntimeDir(), normalizeQaProvider(provider));
 }
 function defaultQaExtensionStageDir(provider = DEFAULT_QA_PROVIDER) {
-  return path17.join(providerDir(provider), "extension-under-test");
+  return path18.join(providerDir(provider), "extension-under-test");
 }
 function defaultQaArtifactsDir(provider = DEFAULT_QA_PROVIDER, clickupTaskId = "unknown") {
-  return path17.join(providerDir(provider), "artifacts", String(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;
@@ -13739,11 +13997,11 @@ async function ensureQaPage(context, { clickupTaskId, startUrl = "https://chatgp
 function copyExtensionSource(sourcePath, stageDir) {
   const source = String(sourcePath || "").trim();
   if (!source) return { ok: true, skipped: true, reason: "extension_path_not_provided", stageDir };
-  const resolved = path17.resolve(source.replace(/^~(?=$|\/)/, os6.homedir()));
-  if (!fs16.existsSync(resolved)) return { ok: false, error: `extension_path_not_found: ${resolved}`, stageDir };
-  fs16.rmSync(stageDir, { recursive: true, force: true });
-  fs16.mkdirSync(path17.dirname(stageDir), { recursive: true });
-  fs16.cpSync(resolved, 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)
   });
@@ -13832,8 +14090,8 @@ async function runQaCommandOnPage(page, context, browser, command, { artifactsDi
   }
   if (action === "screenshot") {
     const name = String(command.name || `screenshot-${Date.now()}.png`).replace(/[^a-zA-Z0-9._-]+/g, "-");
-    const outPath = path17.join(artifactsDir, name);
-    fs16.mkdirSync(path17.dirname(outPath), { recursive: true });
+    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 };
   }
@@ -13855,7 +14113,9 @@ ${script}
 }
 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));
+  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;
@@ -13866,7 +14126,10 @@ async function withQaBrowser({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "", clic
   }
 }
 async function qaBrowserStatus(options = {}) {
-  return withQaBrowser(options, async ({ context }) => ({ ok: true, ...await summarizeBrowser(context, { clickupTaskId: options.clickupTaskId }) })).catch((error) => ({ ok: false, error: error.message, cdpUrl: normalizeCdpUrl(options.cdpUrl) }));
+  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);
@@ -13875,7 +14138,10 @@ async function qaPrepareExtension({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "",
     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((error) => ({ ok: false, error: error.message }));
+  }).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/" } = {}) {
@@ -13884,14 +14150,24 @@ async function qaRunChromeCommand({ provider = DEFAULT_QA_PROVIDER, cdpUrl = "",
   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 fs17 from "node:fs";
-import path18 from "node:path";
+import fs18 from "node:fs";
+import path19 from "node:path";
 var CODEMAP_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".ts",
@@ -13929,10 +14205,10 @@ var LEGACY_OPERATIONAL_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var OPTIMA_OPERATIONAL_FOLDERS = [".optima", "templates", "dist"];
 function relPath(worktree, targetPath) {
-  return path18.relative(worktree, targetPath).split(path18.sep).join("/") || ".";
+  return path19.relative(worktree, targetPath).split(path19.sep).join("/") || ".";
 }
 function normalizeCodemapRelPath(relPathValue) {
-  return path18.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
+  return path19.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
 }
 function firstPathSegment(relPathValue) {
   return normalizeCodemapRelPath(relPathValue).split("/").filter(Boolean)[0] || "";
@@ -13951,8 +14227,8 @@ function isHiddenTree(relPathValue) {
 function loadGitIgnoreMatcher(worktree) {
   const ig = (0, import_ignore.default)();
   ig.add(".git");
-  const gitignorePath = path18.join(worktree, ".gitignore");
-  if (fs17.existsSync(gitignorePath)) ig.add(fs17.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path19.join(worktree, ".gitignore");
+  if (fs18.existsSync(gitignorePath)) ig.add(fs18.readFileSync(gitignorePath, "utf8"));
   return ig;
 }
 function codemapSectionEntries(value) {
@@ -13971,7 +14247,7 @@ function codemapIndexedPaths(map) {
 }
 function readCodemap(filePath, unresolved, worktree) {
   try {
-    const parsed = import_yaml4.default.parse(fs17.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;
@@ -13983,42 +14259,42 @@ function readCodemap(filePath, unresolved, worktree) {
   }
 }
 function writeCodemap(filePath, map) {
-  fs17.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 (!fs17.existsSync(dirPath)) return false;
-  for (const item of fs17.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path18.join(dirPath, item.name);
-    const relative = path18.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(path18.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 (!fs17.existsSync(dirPath)) return false;
-  const dirRelPath = path18.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 fs17.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path18.join(dirPath, item.name);
-    const relative = path18.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(path18.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 = fs17.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs18.readdirSync(dirPath, { withFileTypes: true });
   const entrypoints = [];
   const internals = [];
-  const relToRoot = path18.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path18.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(path18.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 });
   }
@@ -14031,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 = path18.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"]) {
@@ -14042,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://") || path18.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 = path18.join(pathBase, normalizedPath);
-      if (!fs17.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;
@@ -14057,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 = path18.join(pathBase, localPath);
-        if (fs17.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}'.` });
@@ -14072,11 +14348,11 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
     }
     if (Array.isArray(map[section])) map[section] = nextEntries;
   }
-  if (map.scope === "module" && !isOperationalRelPath(path18.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 fs17.readdirSync(mapDir, { withFileTypes: true })) {
-      if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path18.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);
@@ -14090,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 = !fs17.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 (fs17.existsSync(rootCodemapPath)) repairSingleCodemap(rootCodemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-  const rootMap = fs17.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) {
@@ -14108,10 +14384,10 @@ function repairCodemaps(worktree, apply, actions, unresolved, deps) {
     }
   }
   function walk(dirPath) {
-    const relative = path18.relative(worktree, dirPath);
+    const relative = path19.relative(worktree, dirPath);
     if (relative && (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative))) return;
-    const codemapPath = path18.join(dirPath, "codemap.yml");
-    const hasCodemap = fs17.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)) {
@@ -14130,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 (fs17.existsSync(codemapPath) && codemapPath !== rootCodemapPath) repairSingleCodemap(codemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-    for (const item of fs17.readdirSync(dirPath, { withFileTypes: true })) {
-      if (item.isDirectory()) walk(path18.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 (fs17.existsSync(worktree)) walk(worktree);
+  if (fs18.existsSync(worktree)) walk(worktree);
   if (rootMap && rootChanged && apply) writeCodemap(rootCodemapPath, rootMap);
 }
 function walkMarkdownFiles(dirPath) {
-  if (!fs17.existsSync(dirPath)) return [];
+  if (!fs18.existsSync(dirPath)) return [];
   const files = [];
-  for (const entry of fs17.readdirSync(dirPath, { withFileTypes: true })) {
-    const entryPath = path18.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")) {
@@ -14181,7 +14457,7 @@ function rewriteOptimaMarkdownReferences(content, evidenceBasePath = null) {
 }
 function optimaEvidenceBaseForFile(worktree, filePath, deps) {
   const evidenceRoot = deps.optimaEvidencesDir(worktree);
-  const relative = path18.relative(evidenceRoot, filePath).split(path18.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}`;
@@ -14194,11 +14470,11 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
   ];
   const changed = [];
   for (const filePath of scanRoots.flatMap(walkMarkdownFiles)) {
-    const raw = fs17.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path18.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) {
-      fs17.writeFileSync(filePath, rewritten, "utf8");
+      fs18.writeFileSync(filePath, rewritten, "utf8");
       changed.push(relPath(worktree, filePath));
     }
   }
@@ -14206,8 +14482,8 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
 }
 function missingOptimaGitignoreRules(worktree, deps) {
   if (!deps.isGitRepository(worktree)) return [];
-  const gitignorePath = path18.join(worktree, ".gitignore");
-  const existing = fs17.existsSync(gitignorePath) ? fs17.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));
 }
@@ -14224,11 +14500,11 @@ function planOptimaRepair(worktree, args = {}, deps) {
   const apply = mode === "apply";
   const actions = [];
   const unresolved = [];
-  const hadOptima = fs17.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 = fs17.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path18.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.");
@@ -14237,31 +14513,31 @@ function planOptimaRepair(worktree, args = {}, deps) {
     [".staticeng/", deps.legacyStaticEngDir(worktree)],
     [".nomadwork/", deps.legacyNomadworkDir(worktree)],
     [".nomadworks/", deps.legacyNomadworksDir(worktree)],
-    ["tasks/", path18.join(worktree, "tasks")],
-    ["evidences/", path18.join(worktree, "evidences")],
-    ["docs/scrs/", path18.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path18.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path18.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/", path18.join(worktree, "policies")]);
+  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path19.join(worktree, "policies")]);
   for (const [display, sourcePath] of legacySources) {
-    if (fs17.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 = !fs17.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 = [
-    [path18.join(deps.optimaTasksDir(worktree), "current.md"), "registry", ".optima/tasks/current.md", deps.currentTasksRegistryContent()],
-    [path18.join(deps.optimaTasksDir(worktree), "done.md"), "registry", ".optima/tasks/done.md", deps.doneTasksRegistryContent()],
-    [path18.join(deps.optimaScrsDir(worktree), "current.md"), "registry", ".optima/docs/scrs/current.md", deps.currentScrRegistryContent()],
-    [path18.join(deps.optimaScrsDir(worktree), "done.md"), "registry", ".optima/docs/scrs/done.md", deps.doneScrRegistryContent()],
-    [path18.join(deps.optimaTasksDir(worktree), "task-template.md"), "template", ".optima/tasks/task-template.md", deps.taskTemplateContent()],
-    [path18.join(deps.optimaTasksDir(worktree), "subtask-template.md"), "template", ".optima/tasks/subtask-template.md", deps.subtaskTemplateContent()],
-    [path18.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 (!fs17.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);
     }
@@ -14315,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 fs18 from "node:fs";
-import path19 from "node:path";
+import fs19 from "node:fs";
+import path20 from "node:path";
 async function optima_validate_logic(worktree) {
-  const rootCodemapPath = path19.join(worktree, ".optima", "codemap.yml");
-  if (!fs18.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 = path19.join(worktree, ".gitignore");
-  if (fs18.existsSync(gitignorePath)) {
-    ig.add(fs18.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path20.join(worktree, ".gitignore");
+  if (fs19.existsSync(gitignorePath)) {
+    ig.add(fs19.readFileSync(gitignorePath, "utf8"));
   }
   const sourceExtensions = [
     ".js",
@@ -14366,30 +14642,30 @@ async function optima_validate_logic(worktree) {
   const operationalFolders = [".optima", "templates", "dist"];
   const isHiddenTree2 = (relPath2) => {
     if (!relPath2) return false;
-    return relPath2.split(path19.sep).some((part) => part.startsWith("."));
+    return relPath2.split(path20.sep).some((part) => part.startsWith("."));
   };
-  const firstPathSegment2 = (relPath2) => relPath2.split(path19.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 + path19.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) => path19.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizeRelativePath = (relPath2) => path20.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
   const isSourceDir = (dirPath) => {
-    const dirRelPath = path19.relative(worktree, dirPath);
+    const dirRelPath = path20.relative(worktree, dirPath);
     if (isOperationalRelPath2(dirRelPath)) return false;
-    const items = fs18.readdirSync(dirPath, { withFileTypes: true });
+    const items = fs19.readdirSync(dirPath, { withFileTypes: true });
     for (const item of items) {
-      const childPath = path19.join(dirPath, item.name);
-      const relPath2 = path19.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(path19.extname(item.name))) return true;
+      if (item.isFile() && sourceExtensions.includes(path20.extname(item.name))) return true;
       if (item.isDirectory()) {
         if (isSourceDir(childPath)) return true;
       }
@@ -14397,7 +14673,7 @@ async function optima_validate_logic(worktree) {
     return false;
   };
   function validateMap(filePath) {
-    const content = fs18.readFileSync(filePath, "utf8");
+    const content = fs19.readFileSync(filePath, "utf8");
     let map;
     try {
       map = import_yaml5.default.parse(content);
@@ -14409,32 +14685,32 @@ async function optima_validate_logic(worktree) {
       errors.push(`${filePath}: Invalid YAML.`);
       return;
     }
-    const dir = path19.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(path19.normalize(item.path));
+          indexedPaths.add(path20.normalize(item.path));
           if (section === "links" && (item.path.startsWith("http://") || item.path.startsWith("https://"))) {
             continue;
           }
-          const absPath = path19.isAbsolute(item.path) ? item.path : path19.join(pathBase, item.path);
-          if (!fs18.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 = path19.relative(worktree, dir);
+    const relDir = path20.relative(worktree, dir);
     const isOperational = isOperationalRelPath2(relDir);
     if (map.scope === "module" && !isOperational) {
-      const items = fs18.readdirSync(dir, { withFileTypes: true });
+      const items = fs19.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (item.isFile() && sourceExtensions.includes(path19.extname(item.name))) {
+        if (item.isFile() && sourceExtensions.includes(path20.extname(item.name))) {
           if (item.name === "codemap.yml") continue;
-          if (!indexedPaths.has(path19.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').`);
           }
         }
@@ -14444,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 (path19.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 !== ".");
@@ -14456,18 +14732,18 @@ async function optima_validate_logic(worktree) {
     }
   }
   const walk = (dir) => {
-    const relDir = path19.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 = fs18.existsSync(path19.join(dir, "codemap.yml"));
-    const items = fs18.readdirSync(dir, { withFileTypes: true });
-    if (!relDir.startsWith(path19.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 = fs18.readFileSync(path19.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 = path19.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.`);
           }
         }
@@ -14477,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(path19.join(dir, "codemap.yml"));
+    if (hasCodemap) validateMap(path20.join(dir, "codemap.yml"));
     for (const item of items) {
-      if (item.isDirectory()) walk(path19.join(dir, item.name));
+      if (item.isDirectory()) walk(path20.join(dir, item.name));
     }
   };
   validateMap(rootCodemapPath);
@@ -14499,7 +14775,7 @@ function normalizeWorkflowTaskPath(taskPath) {
   const trimmed = taskPath.trim();
   if (!trimmed) return { ok: false, message: "Error: task_path is required." };
   const normalized = trimmed.replace(/\\/g, "/");
-  if (path20.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,
@@ -14516,10 +14792,10 @@ function normalizeWorkflowTaskPath(taskPath) {
 }
 function readTaskMetadata(taskPath, worktree) {
   if (!taskPath) return {};
-  const absoluteTaskPath = path20.isAbsolute(taskPath) ? taskPath : path20.join(worktree, taskPath);
-  if (!fs19.existsSync(absoluteTaskPath)) return {};
+  const absoluteTaskPath = path21.isAbsolute(taskPath) ? taskPath : path21.join(worktree, taskPath);
+  if (!fs20.existsSync(absoluteTaskPath)) return {};
   try {
-    const raw = fs19.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,
@@ -14542,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() ? path20.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: path20.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: path20.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path21.resolve(clickUpBasePath) };
   }
   return {
     ok: false,
@@ -14565,9 +14841,9 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   const configPath = resolveConfigPath(worktree);
   const discussionRegistry = loadDiscussionRegistry(worktree);
   let repoCfg = { agents: {}, defaults: {}, features: {} };
-  if (fs19.existsSync(configPath)) {
+  if (fs20.existsSync(configPath)) {
     try {
-      repoCfg = import_yaml6.default.parse(fs19.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);
     }
@@ -14872,10 +15148,10 @@ Evidencia: ${evidencePath}` : ""
         }
         migrateLegacyOptimaLayout(toolWorktree);
         const cfgDir = optimaConfigDir(toolWorktree);
-        if (!fs19.existsSync(cfgDir)) fs19.mkdirSync(cfgDir, { recursive: true });
-        const optimaTmplPath = path20.join(TEMPLATES_DIR, "optima.yaml.template");
-        const codemapTmplPath = path20.join(TEMPLATES_DIR, "codemap.yml.template");
-        if (!fs19.existsSync(optimaTmplPath) || !fs19.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);
@@ -14996,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 = path20.resolve(safe.worktree, args.summary_path || "");
-        if (!fs19.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
-        const taskPath = args.task_path ? path20.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: fs19.readFileSync(summaryPath, "utf8"),
-          summaryPath: path20.relative(safe.worktree, summaryPath),
-          taskMarkdown: taskPath && fs19.existsSync(taskPath) ? fs19.readFileSync(taskPath, "utf8") : "",
-          taskPath: taskPath ? path20.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
@@ -15170,7 +15446,7 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
             commandJson: args.command_json,
             startUrl: args.start_url || "https://chatgpt.com/"
           });
-          return JSON.stringify({ ok: true, lease: persisted.state.active, notifications: persisted.notifications, chrome: result }, null, 2);
+          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);
         }
@@ -15218,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 = path20.resolve(safe.worktree, args.markdown_path || "");
-        if (!fs19.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: fs19.readFileSync(markdownPath, "utf8"),
-          sourcePath: path20.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"
@@ -15593,7 +15869,7 @@ Backfilled messages: ${backfilled}`;
         if (!existing) {
           return "FAIL: No active discussion exists for this session.";
         }
-        const discussionPath = path20.join(toolWorktree, existing.transcriptPath);
+        const discussionPath = path21.join(toolWorktree, existing.transcriptPath);
         setDiscussionStatus(discussionPath, "summarizing");
         existing.status = "summarizing";
         saveDiscussionRegistry(toolWorktree, toolRegistry);
@@ -15645,7 +15921,7 @@ Reason: ${err.message}`;
         try {
           const sessionResult = await client.session.create({
             query: { directory: workflowDirectory },
-            body: { title: `Workflow Run: ${path20.basename(workflowTaskPath)}` }
+            body: { title: `Workflow Run: ${path21.basename(workflowTaskPath)}` }
           });
           const sessionId = sessionResult.data.id;
           activeWorkflows.set(sessionId, { pmaSessionId, taskPath: workflowTaskPath, track: workflowTrack, directory: workflowDirectory });
@@ -15830,13 +16106,13 @@ function usage() {
 }
 function expandHome(inputPath) {
   if (!inputPath || inputPath === "~") return os7.homedir();
-  if (inputPath.startsWith("~/")) return path21.join(os7.homedir(), inputPath.slice(2));
+  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 (fs20.existsSync(expanded) && fs20.statSync(expanded).isDirectory()) return path21.join(expanded, "opencode.db");
+    if (fs21.existsSync(expanded) && fs21.statSync(expanded).isDirectory()) return path22.join(expanded, "opencode.db");
   } catch {
     return expanded;
   }
@@ -15900,12 +16176,12 @@ function extractOpenedPathValue(value) {
 }
 function normalizePathCandidate(candidate) {
   const expanded = expandHome(candidate);
-  if (!path21.isAbsolute(expanded)) return null;
-  return path21.resolve(expanded);
+  if (!path22.isAbsolute(expanded)) return null;
+  return path22.resolve(expanded);
 }
 function discoverOpenCodePaths(dbPath) {
   const resolvedDb = resolveOpenCodeDbPath(dbPath);
-  if (!fs20.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) {
@@ -15930,27 +16206,27 @@ function discoverOpenCodePaths(dbPath) {
 function collectMarkdownOverridesFrom(baseDir) {
   const files = [];
   for (const dirName of OVERRIDE_DIRS) {
-    const dirPath = path21.join(baseDir, dirName);
-    if (!fs20.existsSync(dirPath)) continue;
-    for (const entry of fs20.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(path21.join(dirPath, entry.name));
+      files.push(path22.join(dirPath, entry.name));
     }
   }
   return files;
 }
 function collectOverrideFiles(worktree) {
-  return collectMarkdownOverridesFrom(path21.join(worktree, ".optima")).sort();
+  return collectMarkdownOverridesFrom(path22.join(worktree, ".optima")).sort();
 }
 function collectPlannedOverrideFiles(worktree) {
   return [
     ...collectOverrideFiles(worktree),
-    ...collectMarkdownOverridesFrom(path21.join(worktree, ".staticeng")),
-    ...collectMarkdownOverridesFrom(path21.join(worktree, ".orbita")),
-    ...collectMarkdownOverridesFrom(path21.join(worktree, ".nomadwork")),
-    ...collectMarkdownOverridesFrom(path21.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 = (() => {
@@ -15983,14 +16259,14 @@ function writeUInt16LE(value) {
   return buffer;
 }
 function createZipBackup(files, backupPath) {
-  fs20.mkdirSync(path21.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 = fs20.readFileSync(filePath);
-    const name = path21.resolve(filePath).replace(/^\//, "").split(path21.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([
@@ -16042,7 +16318,7 @@ function createZipBackup(files, backupPath) {
     writeUInt32LE(offset),
     writeUInt16LE(0)
   ]);
-  fs20.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");
@@ -16052,17 +16328,17 @@ function validationStatus(result) {
   return result.ok ? "passed" : "failed";
 }
 function hasLegacyMarker(worktree) {
-  return fs20.existsSync(path21.join(worktree, ".staticeng")) || fs20.existsSync(path21.join(worktree, ".orbita")) || fs20.existsSync(path21.join(worktree, ".nomadwork")) || fs20.existsSync(path21.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/", path21.join(worktree, "tasks")],
-    ["evidences/", path21.join(worktree, "evidences")],
-    ["docs/scrs/", path21.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path21.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path21.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) => fs20.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;
@@ -16088,7 +16364,7 @@ function planOptimaMigration(worktree, dryRun) {
       ...overrides.map((file) => ({
         category: "override",
         action: dryRun ? "would_remove_after_backup" : "removed_after_backup",
-        path: path21.relative(worktree, file).split(path21.sep).join("/"),
+        path: path22.relative(worktree, file).split(path22.sep).join("/"),
         detail: "Remove implicit agent/policy override after host-level backup."
       }))
     ],
@@ -16109,12 +16385,12 @@ async function sanitizeHost(options = {}) {
   const repoStates = [];
   for (const candidate of paths) {
     try {
-      if (!fs20.existsSync(candidate)) {
+      if (!fs21.existsSync(candidate)) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "missing" });
         continue;
       }
-      if (!fs20.statSync(candidate).isDirectory()) {
+      if (!fs21.statSync(candidate).isDirectory()) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "not_directory" });
         continue;
@@ -16136,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 = path21.join(os7.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;
@@ -16152,7 +16428,7 @@ async function sanitizeHost(options = {}) {
   for (const state of repoStates) {
     try {
       if (!dryRun) {
-        for (const file of state.overrideFiles) fs20.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";
@@ -16165,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) => path21.relative(state.repo, file).split(path21.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
       });