@defend-tech/opencode-optima 0.1.75 → 0.1.77

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, path8) {
-      const ctrl = callVisitor(key, node, visitor, path8);
+    function visit_(key, node, visitor, path10) {
+      const ctrl = callVisitor(key, node, visitor, path10);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path8, ctrl);
-        return visit_(key, ctrl, visitor, path8);
+        replaceNode(key, path10, ctrl);
+        return visit_(key, ctrl, visitor, path10);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path8 = Object.freeze(path8.concat(node));
+          path10 = Object.freeze(path10.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path8);
+            const ci = visit_(i, node.items[i], visitor, path10);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -130,13 +130,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path8 = Object.freeze(path8.concat(node));
-          const ck = visit_("key", node.key, visitor, path8);
+          path10 = Object.freeze(path10.concat(node));
+          const ck = visit_("key", node.key, visitor, path10);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path8);
+          const cv = visit_("value", node.value, visitor, path10);
           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, path8) {
-      const ctrl = await callVisitor(key, node, visitor, path8);
+    async function visitAsync_(key, node, visitor, path10) {
+      const ctrl = await callVisitor(key, node, visitor, path10);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path8, ctrl);
-        return visitAsync_(key, ctrl, visitor, path8);
+        replaceNode(key, path10, ctrl);
+        return visitAsync_(key, ctrl, visitor, path10);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path8 = Object.freeze(path8.concat(node));
+          path10 = Object.freeze(path10.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path8);
+            const ci = await visitAsync_(i, node.items[i], visitor, path10);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -178,13 +178,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path8 = Object.freeze(path8.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path8);
+          path10 = Object.freeze(path10.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path10);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path8);
+          const cv = await visitAsync_("value", node.value, visitor, path10);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -211,23 +211,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path8) {
+    function callVisitor(key, node, visitor, path10) {
       if (typeof visitor === "function")
-        return visitor(key, node, path8);
+        return visitor(key, node, path10);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path8);
+        return visitor.Map?.(key, node, path10);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path8);
+        return visitor.Seq?.(key, node, path10);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path8);
+        return visitor.Pair?.(key, node, path10);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path8);
+        return visitor.Scalar?.(key, node, path10);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path8);
+        return visitor.Alias?.(key, node, path10);
       return void 0;
     }
-    function replaceNode(key, path8, node) {
-      const parent = path8[path8.length - 1];
+    function replaceNode(key, path10, node) {
+      const parent = path10[path10.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, path8, value) {
+    function collectionFromPath(schema, path10, value) {
       let v = value;
-      for (let i = path8.length - 1; i >= 0; --i) {
-        const k = path8[i];
+      for (let i = path10.length - 1; i >= 0; --i) {
+        const k = path10[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 = (path8) => path8 == null || typeof path8 === "object" && !!path8[Symbol.iterator]().next().done;
+    var isEmptyPath = (path10) => path10 == null || typeof path10 === "object" && !!path10[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(path8, value) {
-        if (isEmptyPath(path8))
+      addIn(path10, value) {
+        if (isEmptyPath(path10))
           this.add(value);
         else {
-          const [key, ...rest] = path8;
+          const [key, ...rest] = path10;
           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(path8) {
-        const [key, ...rest] = path8;
+      deleteIn(path10) {
+        const [key, ...rest] = path10;
         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(path8, keepScalar) {
-        const [key, ...rest] = path8;
+      getIn(path10, keepScalar) {
+        const [key, ...rest] = path10;
         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(path8) {
-        const [key, ...rest] = path8;
+      hasIn(path10) {
+        const [key, ...rest] = path10;
         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(path8, value) {
-        const [key, ...rest] = path8;
+      setIn(path10, value) {
+        const [key, ...rest] = path10;
         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(path8, value) {
+      addIn(path10, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path8, value);
+          this.contents.addIn(path10, 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(path8) {
-        if (Collection.isEmptyPath(path8)) {
+      deleteIn(path10) {
+        if (Collection.isEmptyPath(path10)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path8) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path10) : 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(path8, keepScalar) {
-        if (Collection.isEmptyPath(path8))
+      getIn(path10, keepScalar) {
+        if (Collection.isEmptyPath(path10))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path8, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path10, 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(path8) {
-        if (Collection.isEmptyPath(path8))
+      hasIn(path10) {
+        if (Collection.isEmptyPath(path10))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path8) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path10) : 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(path8, value) {
-        if (Collection.isEmptyPath(path8)) {
+      setIn(path10, value) {
+        if (Collection.isEmptyPath(path10)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path8), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path10), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path8, value);
+          this.contents.setIn(path10, value);
         }
       }
       /**
@@ -5546,9 +5546,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path8) => {
+    visit.itemAtPath = (cst, path10) => {
       let item = cst;
-      for (const [field, index] of path8) {
+      for (const [field, index] of path10) {
         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, path8) => {
-      const parent = visit.itemAtPath(cst, path8.slice(0, -1));
-      const field = path8[path8.length - 1][0];
+    visit.parentCollection = (cst, path10) => {
+      const parent = visit.itemAtPath(cst, path10.slice(0, -1));
+      const field = path10[path10.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path8, item, visitor) {
-      let ctrl = visitor(item, path8);
+    function _visit(path10, item, visitor) {
+      let ctrl = visitor(item, path10);
       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(path8.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path10.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, path8);
+            ctrl = ctrl(item, path10);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path8) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path10) : ctrl;
     }
     exports.visit = visit;
   }
@@ -6872,14 +6872,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs7 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs7, sep: [] });
+                map.items.push({ start, key: fs10, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs7);
+                this.stack.push(fs10);
               } else {
-                Object.assign(it, { key: fs7, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -7007,13 +7007,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs7 = this.flowScalar(this.type);
+              const fs10 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs7, sep: [] });
+                fc.items.push({ start: [], key: fs10, sep: [] });
               else if (it.sep)
-                this.stack.push(fs7);
+                this.stack.push(fs10);
               else
-                Object.assign(it, { key: fs7, sep: [] });
+                Object.assign(it, { key: fs10, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7551,17 +7551,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path8, originalPath, doThrow) => {
-      if (!isString(path8)) {
+    var checkPath = (path10, originalPath, doThrow) => {
+      if (!isString(path10)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path8) {
+      if (!path10) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path8)) {
+      if (checkPath.isNotRelative(path10)) {
         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 = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
+    var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
     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(path8, checkUnignored) {
+      _testOne(path10, 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(path8);
+          const matched = rule.regex.test(path10);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7650,24 +7650,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path8 = originalPath && checkPath.convert(originalPath);
+        const path10 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path8,
+          path10,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path8, cache, checkUnignored, slices);
+        return this._t(path10, cache, checkUnignored, slices);
       }
-      _t(path8, cache, checkUnignored, slices) {
-        if (path8 in cache) {
-          return cache[path8];
+      _t(path10, cache, checkUnignored, slices) {
+        if (path10 in cache) {
+          return cache[path10];
         }
         if (!slices) {
-          slices = path8.split(SLASH);
+          slices = path10.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path8] = this._testOne(path8, checkUnignored);
+          return cache[path10] = this._testOne(path10, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7675,24 +7675,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
+        return cache[path10] = parent.ignored ? parent : this._testOne(path10, checkUnignored);
       }
-      ignores(path8) {
-        return this._test(path8, this._ignoreCache, false).ignored;
+      ignores(path10) {
+        return this._test(path10, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path8) => !this.ignores(path8);
+        return (path10) => !this.ignores(path10);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path8) {
-        return this._test(path8, this._testCache, true);
+      test(path10) {
+        return this._test(path10, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
+    var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7703,27 +7703,59 @@ 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 = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
+      checkPath.isNotRelative = (path10) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
     }
   }
 });
 
 // src/sanitize_cli.js
-import fs6 from "node:fs";
-import os2 from "node:os";
-import path7 from "node:path";
+import fs9 from "node:fs";
+import os3 from "node:os";
+import path9 from "node:path";
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 
 // src/index.js
 var import_yaml3 = __toESM(require_dist(), 1);
 var import_ignore3 = __toESM(require_ignore(), 1);
-import crypto from "node:crypto";
-import fs5 from "node:fs";
+import crypto2 from "node:crypto";
+import fs8 from "node:fs";
 import http from "node:http";
-import os from "node:os";
-import path6 from "node:path";
+import os2 from "node:os";
+import path8 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 
+// src/clickup_comments.js
+var COMMENT_TEXT_KEYS = /* @__PURE__ */ new Set(["comment", "body", "description"]);
+function normalizeClickUpMarkdown(value = "") {
+  return String(value ?? "").replace(/\\r\\n/g, "\n").replace(/\\n/g, "\n").replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+function formatClickUpStatusComment({ title = "", summary = "", sections = [], context = [] } = {}) {
+  const lines = [];
+  const heading = normalizeClickUpMarkdown(title);
+  if (heading) lines.push(`## ${heading}`, "");
+  const intro = normalizeClickUpMarkdown(summary);
+  if (intro) lines.push(intro, "");
+  for (const section of sections) {
+    const sectionTitle = normalizeClickUpMarkdown(section?.title);
+    const sectionBody = normalizeClickUpMarkdown(section?.body);
+    if (!sectionTitle || !sectionBody) continue;
+    lines.push(`### ${sectionTitle}`, sectionBody, "");
+  }
+  const contextLines = context.map(normalizeClickUpMarkdown).filter(Boolean);
+  if (contextLines.length > 0) lines.push("### Context", contextLines.map((item) => item.startsWith("- ") ? item : `- ${item}`).join("\n"));
+  return normalizeClickUpMarkdown(lines.join("\n"));
+}
+function normalizeClickUpPayloadComments(value) {
+  if (Array.isArray(value)) return value.map(normalizeClickUpPayloadComments);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [
+      key,
+      COMMENT_TEXT_KEYS.has(key) && typeof entry === "string" ? normalizeClickUpMarkdown(entry) : normalizeClickUpPayloadComments(entry)
+    ])
+  );
+}
+
 // src/git_utils.js
 import fs from "node:fs";
 import path from "node:path";
@@ -7802,24 +7834,438 @@ function stageGitAwareMerge(sourcePath, destinationPath, gitState) {
   }
 }
 
-// src/include_resolver.js
+// src/github.js
+import crypto from "node:crypto";
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// src/secrets.js
 import fs2 from "node:fs";
+import os from "node:os";
 import path2 from "node:path";
+function expandHomePath(value = "") {
+  const input = String(value || "").trim();
+  if (input === "~") return os.homedir();
+  if (input.startsWith("~/")) return path2.join(os.homedir(), input.slice(2));
+  return input;
+}
+function resolveSecretReference(value = "") {
+  const raw = String(value || "").trim();
+  const envMatch = raw.match(/^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/);
+  if (envMatch) return process.env[envMatch[1]] || "";
+  const fileMatch = raw.match(/^\{file:(.+)\}$/);
+  if (fileMatch) {
+    try {
+      return fs2.readFileSync(expandHomePath(fileMatch[1]), "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+  return raw;
+}
+
+// src/github.js
+function base64UrlJson(value) {
+  return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function resolveGitHubAppPrivateKey(app = {}) {
+  const direct = resolveSecretReference(app.privateKey || "");
+  if (direct) return direct.replace(/\\n/g, "\n");
+  const file = expandHomePath(app.privateKeyFile || "");
+  if (!file) return "";
+  try {
+    return fs3.readFileSync(file, "utf8").trim().replace(/\\n/g, "\n");
+  } catch {
+    return "";
+  }
+}
+function createGitHubAppJwt({ appId, privateKey, now = () => /* @__PURE__ */ new Date() } = {}) {
+  const key = String(privateKey || "").trim();
+  const issuer = String(appId || "").trim();
+  if (!issuer || !key) throw new Error("GitHub App app_id and private key are required");
+  const nowSeconds = Math.floor(now().getTime() / 1e3);
+  const header = base64UrlJson({ alg: "RS256", typ: "JWT" });
+  const payload = base64UrlJson({ iat: nowSeconds - 60, exp: nowSeconds + 540, iss: issuer });
+  const unsigned = `${header}.${payload}`;
+  const signature = crypto.createSign("RSA-SHA256").update(unsigned).end().sign(key, "base64url");
+  return `${unsigned}.${signature}`;
+}
+function encodeGitHubPathSegment(value) {
+  return encodeURIComponent(String(value || ""));
+}
+function encodeGitHubBranchRef(branch = "") {
+  return String(branch || "").split("/").map(encodeGitHubPathSegment).join("/");
+}
+function parseNullSeparatedGitOutput(output = "") {
+  return String(output || "").split("\0").map((item) => item.trim()).filter(Boolean);
+}
+function listWorktreeChangedPaths(worktree, runGitFn = runGit) {
+  const tracked = parseNullSeparatedGitOutput(runGitFn(worktree, ["diff", "--name-only", "-z", "HEAD", "--"]));
+  const untracked = parseNullSeparatedGitOutput(runGitFn(worktree, ["ls-files", "--others", "--exclude-standard", "-z", "--"]));
+  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])].filter((item) => item && !item.startsWith("../") && !path3.isAbsolute(item));
+}
+function currentGitBranch(worktree, runGitFn = runGit) {
+  return String(runGitFn(worktree, ["rev-parse", "--abbrev-ref", "HEAD"]) || "").trim();
+}
+function treeEntryForWorktreePath(worktree, gitPath) {
+  const absolutePath = path3.join(worktree, ...String(gitPath || "").split("/"));
+  if (!fs3.existsSync(absolutePath)) return { path: gitPath, mode: "100644", type: "blob", sha: null, deleted: true };
+  const stat = fs3.lstatSync(absolutePath);
+  if (stat.isDirectory()) return null;
+  if (stat.isSymbolicLink()) {
+    return {
+      path: gitPath,
+      mode: "120000",
+      type: "blob",
+      content: fs3.readlinkSync(absolutePath),
+      encoding: "utf-8"
+    };
+  }
+  return {
+    path: gitPath,
+    mode: stat.mode & 73 ? "100755" : "100644",
+    type: "blob",
+    content: fs3.readFileSync(absolutePath).toString("base64"),
+    encoding: "base64"
+  };
+}
+function appendGitHubQuery(pathname, params = {}) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params || {})) {
+    if (value === void 0 || value === null || value === "") continue;
+    query.set(key, String(value));
+  }
+  const suffix = query.toString();
+  return suffix ? `${pathname}?${suffix}` : pathname;
+}
+function timestampMs(value = "") {
+  const parsed = Date.parse(String(value || ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function sortNewestFirst(items = []) {
+  return [...items].sort((a, b) => {
+    const bTime = Math.max(timestampMs(b?.updated_at), timestampMs(b?.created_at));
+    const aTime = Math.max(timestampMs(a?.updated_at), timestampMs(a?.created_at));
+    return bTime - aTime;
+  });
+}
+function matchesVercelStatusContext(context = "", expected = "") {
+  const actual = String(context || "").trim();
+  const wanted = String(expected || "").trim();
+  if (wanted && actual === wanted) return true;
+  const lower = actual.toLowerCase();
+  if (!lower.includes("vercel")) return false;
+  if (!wanted) return lower.includes("preproduction") || lower.includes("defend-preproduction");
+  const wantedLower = wanted.toLowerCase();
+  return wantedLower.split(/\s+|–|-/).filter((part) => part && part !== "vercel").every((part) => lower.includes(part));
+}
+function selectFunctionalDeploymentUrl(status = {}, deployment = {}) {
+  for (const candidate of [
+    status?.environment_url,
+    deployment?.environment_url,
+    status?.target_url,
+    deployment?.target_url
+  ]) {
+    const value = String(candidate || "").trim();
+    if (!value) continue;
+    try {
+      const url = new URL(value);
+      if (url.protocol === "http:" || url.protocol === "https:") return value;
+    } catch {
+    }
+  }
+  return "";
+}
+async function checkFunctionalDeploymentUrl(url, fetchImpl = globalThis.fetch) {
+  const target = String(url || "").trim();
+  if (!target) return { ok: false, reason: "url_missing" };
+  if (typeof fetchImpl !== "function") return { ok: false, reason: "fetch_unavailable", url: target };
+  const signal = typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function" ? AbortSignal.timeout(8e3) : void 0;
+  const probe = async (method) => {
+    const response = await fetchImpl(target, { method, redirect: "follow", signal });
+    return {
+      ok: response.status >= 200 && response.status < 400,
+      status: response.status,
+      statusText: response.statusText || "",
+      url: response.url || target,
+      method
+    };
+  };
+  try {
+    const head = await probe("HEAD");
+    if (head.ok) return head;
+    const get = await probe("GET");
+    return get.ok ? get : { ...get, reason: "http_not_ok" };
+  } catch (error) {
+    try {
+      const get = await probe("GET");
+      return get.ok ? get : { ...get, reason: "http_not_ok" };
+    } catch (secondError) {
+      return { ok: false, reason: "request_failed", url: target, error: secondError.message || error.message };
+    }
+  }
+}
+function createGitHubApiClient(config = {}, fetchImpl = globalThis.fetch) {
+  const staticToken = resolveSecretReference(config?.apiToken);
+  const appConfig = typeof config?.app === "object" && config.app !== null ? config.app : {};
+  const appId = resolveSecretReference(appConfig.appId || appConfig.app_id || "");
+  const installationId = resolveSecretReference(appConfig.installationId || appConfig.installation_id || "");
+  const appEnabled = appConfig.enabled === true || Boolean(appId && installationId && (appConfig.privateKey || appConfig.privateKeyFile));
+  const privateKey = resolveGitHubAppPrivateKey(appConfig);
+  const owner = String(config?.owner || "").trim();
+  const repo = String(config?.repo || "").trim();
+  let installationToken = null;
+  let installationTokenExpiresAt = 0;
+  const requestJson = async (url, { method = "GET", headers = {}, body = void 0 } = {}) => {
+    if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable; inject a GitHub client for live PR lookup");
+    const response = await fetchImpl(url, {
+      method,
+      headers: {
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28",
+        ...body === void 0 ? {} : { "Content-Type": "application/json" },
+        ...headers
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+    if (!response.ok) throw new Error(`GitHub API request failed: ${response.status}`);
+    return response.status === 204 ? null : response.json();
+  };
+  const getAuthToken = async () => {
+    if (!appEnabled) return staticToken || "";
+    const nowMs = Date.now();
+    if (installationToken && installationTokenExpiresAt - 6e4 > nowMs) return installationToken;
+    const jwt = createGitHubAppJwt({ appId, privateKey });
+    const installation = await requestJson(`https://api.github.com/app/installations/${encodeURIComponent(installationId)}/access_tokens`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${jwt}` }
+    });
+    installationToken = String(installation?.token || "").trim();
+    installationTokenExpiresAt = Date.parse(installation?.expires_at || "") || nowMs + 3e6;
+    if (!installationToken) throw new Error("GitHub App installation token response did not include a token");
+    return installationToken;
+  };
+  const request = async (pathname, { method = "GET", body = void 0 } = {}) => {
+    if (!owner || !repo) throw new Error("GitHub repository owner/repo is not configured");
+    const token = await getAuthToken();
+    return requestJson(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}${pathname}`, {
+      method,
+      body,
+      headers: token ? { Authorization: `Bearer ${token}` } : {}
+    });
+  };
+  const getRef = async (branch) => request(`/git/ref/heads/${encodeGitHubBranchRef(branch)}`);
+  const getCommitObject = async (sha) => request(`/git/commits/${encodeURIComponent(sha)}`);
+  const createBlob = async ({ content, encoding }) => request("/git/blobs", { method: "POST", body: { content, encoding } });
+  const createTree = async ({ baseTree, tree }) => request("/git/trees", { method: "POST", body: { base_tree: baseTree, tree } });
+  const createCommit = async ({ message, treeSha, parents }) => request("/git/commits", { method: "POST", body: { message, tree: treeSha, parents } });
+  const updateRef = async ({ branch, sha, force = false }) => request(`/git/refs/heads/${encodeGitHubBranchRef(branch)}`, { method: "PATCH", body: { sha, force } });
+  return {
+    async getPullRequest(number) {
+      return request(`/pulls/${encodeURIComponent(number)}`);
+    },
+    async createPullRequest({ title, head, base, body = "", draft = false, maintainerCanModify = true }) {
+      return request("/pulls", {
+        method: "POST",
+        body: {
+          title: String(title || ""),
+          head: String(head || ""),
+          base: String(base || ""),
+          body: String(body || ""),
+          draft: draft === true,
+          maintainer_can_modify: maintainerCanModify !== false
+        }
+      });
+    },
+    async createIssueComment({ issueNumber, body }) {
+      return request(`/issues/${encodeURIComponent(issueNumber)}/comments`, { method: "POST", body: { body: String(body || "") } });
+    },
+    async replyToReviewComment({ commentId, body }) {
+      return request(`/pulls/comments/${encodeURIComponent(commentId)}/replies`, { method: "POST", body: { body: String(body || "") } });
+    },
+    async createPullRequestReview({ pullNumber, body, event = "COMMENT" }) {
+      return request(`/pulls/${encodeURIComponent(pullNumber)}/reviews`, { method: "POST", body: { body: String(body || ""), event: String(event || "COMMENT").toUpperCase() } });
+    },
+    async mergePullRequest({ pullNumber, commitTitle = "", commitMessage = "", mergeMethod = "squash" }) {
+      const body = { merge_method: String(mergeMethod || "squash") };
+      if (commitTitle) body.commit_title = String(commitTitle);
+      if (commitMessage) body.commit_message = String(commitMessage);
+      return request(`/pulls/${encodeURIComponent(pullNumber)}/merge`, { method: "PUT", body });
+    },
+    async getCombinedStatus(ref) {
+      return request(`/commits/${encodeURIComponent(String(ref || ""))}/status`);
+    },
+    async listDeployments({ sha = "", ref = "", environment = "", perPage = 30 } = {}) {
+      return request(appendGitHubQuery("/deployments", { sha, ref, environment, per_page: perPage }));
+    },
+    async listDeploymentStatuses(deploymentId) {
+      return request(`/deployments/${encodeURIComponent(deploymentId)}/statuses`);
+    },
+    async verifyVercelPullRequestDeployment({
+      pullNumber,
+      context = "Vercel \u2013 defend-preproduction",
+      environment = "Preview \u2013 defend-preproduction",
+      requireFunctionalUrl = true
+    } = {}) {
+      const pr = await this.getPullRequest(pullNumber);
+      const headSha = String(pr?.head?.sha || "").trim();
+      if (!headSha) return { ok: true, ready: false, reason: "pr_head_sha_missing", pull_request: { number: pullNumber } };
+      const combined = await this.getCombinedStatus(headSha);
+      const statuses = Array.isArray(combined?.statuses) ? combined.statuses : [];
+      const selectedStatus = sortNewestFirst(statuses.filter((status) => matchesVercelStatusContext(status?.context, context)))[0] || null;
+      if (!selectedStatus) {
+        return {
+          ok: true,
+          ready: false,
+          reason: "vercel_status_missing",
+          pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+          required_context: context,
+          combined_state: combined?.state || null
+        };
+      }
+      if (String(selectedStatus.state || "").toLowerCase() !== "success") {
+        return {
+          ok: true,
+          ready: false,
+          reason: "vercel_status_not_success",
+          pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+          required_context: context,
+          status: selectedStatus,
+          combined_state: combined?.state || null
+        };
+      }
+      let deployments = await this.listDeployments({ sha: headSha, environment });
+      if (!Array.isArray(deployments) || deployments.length === 0) deployments = await this.listDeployments({ sha: headSha });
+      const newestDeployments = sortNewestFirst(Array.isArray(deployments) ? deployments : []);
+      const selectedDeployment = newestDeployments.find((deployment) => !environment || String(deployment?.environment || "") === environment) || newestDeployments[0] || null;
+      if (!selectedDeployment?.id) {
+        return {
+          ok: true,
+          ready: false,
+          reason: "vercel_deployment_missing",
+          pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+          required_environment: environment,
+          status: selectedStatus
+        };
+      }
+      const deploymentStatuses = await this.listDeploymentStatuses(selectedDeployment.id);
+      const selectedDeploymentStatus = sortNewestFirst(Array.isArray(deploymentStatuses) ? deploymentStatuses : [])[0] || null;
+      if (!selectedDeploymentStatus || String(selectedDeploymentStatus.state || "").toLowerCase() !== "success") {
+        return {
+          ok: true,
+          ready: false,
+          reason: "vercel_deployment_not_success",
+          pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+          required_environment: environment,
+          status: selectedStatus,
+          deployment: selectedDeployment,
+          deployment_status: selectedDeploymentStatus
+        };
+      }
+      const url = selectFunctionalDeploymentUrl(selectedDeploymentStatus, selectedDeployment);
+      const urlCheck = requireFunctionalUrl ? await checkFunctionalDeploymentUrl(url, fetchImpl) : { ok: Boolean(url), reason: url ? void 0 : "url_missing", url };
+      if (requireFunctionalUrl && !urlCheck.ok) {
+        return {
+          ok: true,
+          ready: false,
+          reason: "vercel_url_not_functional",
+          pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+          required_environment: environment,
+          status: selectedStatus,
+          deployment: selectedDeployment,
+          deployment_status: selectedDeploymentStatus,
+          url,
+          url_check: urlCheck
+        };
+      }
+      return {
+        ok: true,
+        ready: true,
+        reason: "vercel_pr_deployment_ready",
+        pull_request: { number: pr.number, url: pr.html_url, head_sha: headSha },
+        required_context: context,
+        required_environment: environment,
+        status: selectedStatus,
+        deployment: selectedDeployment,
+        deployment_status: selectedDeploymentStatus,
+        url,
+        url_check: urlCheck
+      };
+    },
+    async commitWorktree({ worktree, branch = "", message = "", runGitFn = runGit, syncLocal = false } = {}) {
+      const directory = path3.resolve(String(worktree || ""));
+      if (!directory || !fs3.existsSync(directory)) throw new Error("worktree does not exist");
+      const targetBranch = String(branch || currentGitBranch(directory, runGitFn)).trim();
+      if (!targetBranch || targetBranch === "HEAD") throw new Error("target branch is required for GitHub API commit");
+      const commitMessage = String(message || "").trim();
+      if (!commitMessage) throw new Error("commit message is required");
+      const changedPaths = listWorktreeChangedPaths(directory, runGitFn);
+      if (changedPaths.length === 0) return { ok: true, action: "no_changes", branch: targetBranch, changedPaths: [] };
+      const ref = await getRef(targetBranch);
+      const headSha = ref?.object?.sha;
+      if (!headSha) throw new Error(`GitHub ref for ${targetBranch} did not include a head sha`);
+      const headCommit = await getCommitObject(headSha);
+      const baseTree = headCommit?.tree?.sha;
+      if (!baseTree) throw new Error(`GitHub commit ${headSha} did not include a tree sha`);
+      const tree = [];
+      for (const gitPath of changedPaths) {
+        const entry = treeEntryForWorktreePath(directory, gitPath);
+        if (!entry) continue;
+        if (entry.deleted) {
+          tree.push({ path: entry.path, mode: entry.mode, type: entry.type, sha: null });
+          continue;
+        }
+        const blob = await createBlob({ content: entry.content, encoding: entry.encoding });
+        if (!blob?.sha) throw new Error(`GitHub blob creation failed for ${gitPath}`);
+        tree.push({ path: entry.path, mode: entry.mode, type: entry.type, sha: blob.sha });
+      }
+      if (tree.length === 0) return { ok: true, action: "no_changes", branch: targetBranch, changedPaths: [] };
+      const nextTree = await createTree({ baseTree, tree });
+      const nextCommit = await createCommit({ message: commitMessage, treeSha: nextTree.sha, parents: [headSha] });
+      if (!nextCommit?.sha) throw new Error("GitHub commit creation did not return a sha");
+      const updatedRef = await updateRef({ branch: targetBranch, sha: nextCommit.sha, force: false });
+      if (syncLocal) {
+        runGitFn(directory, ["fetch", "origin", targetBranch]);
+        runGitFn(directory, ["reset", "--hard", "FETCH_HEAD"]);
+      }
+      return {
+        ok: true,
+        action: "committed",
+        branch: targetBranch,
+        before: headSha,
+        after: nextCommit.sha,
+        changedPaths,
+        treeEntries: tree.length,
+        verification: nextCommit.verification || null,
+        ref: updatedRef
+      };
+    },
+    async authMode() {
+      if (appEnabled) return { mode: "github_app", appId, installationId };
+      if (staticToken) return { mode: "token" };
+      return { mode: "anonymous" };
+    }
+  };
+}
+
+// src/include_resolver.js
+import fs4 from "node:fs";
+import path4 from "node:path";
 function compactPromptPath(filePath) {
   if (!filePath.endsWith(".md") || filePath.endsWith(".prompt.md")) return null;
   return filePath.replace(/\.md$/, ".prompt.md");
 }
 function isSameOrNestedPath(candidate, root) {
   if (typeof candidate !== "string" || typeof root !== "string" || !candidate.trim() || !root.trim()) return false;
-  const resolvedCandidate = path2.resolve(candidate);
-  const resolvedRoot = path2.resolve(root);
-  const relative = path2.relative(resolvedRoot, resolvedCandidate);
-  return relative === "" || !!relative && !relative.startsWith("..") && !path2.isAbsolute(relative);
+  const resolvedCandidate = path4.resolve(candidate);
+  const resolvedRoot = path4.resolve(root);
+  const relative = path4.relative(resolvedRoot, resolvedCandidate);
+  return relative === "" || !!relative && !relative.startsWith("..") && !path4.isAbsolute(relative);
 }
 function resolveWithin(baseDir, relativePath) {
   if (!relativePath) return null;
-  if (path2.isAbsolute(relativePath)) return null;
-  const resolved = path2.resolve(baseDir, relativePath);
+  if (path4.isAbsolute(relativePath)) return null;
+  const resolved = path4.resolve(baseDir, relativePath);
   return isSameOrNestedPath(resolved, baseDir) ? resolved : null;
 }
 function withCompactPreference(paths, options = {}) {
@@ -7832,18 +8278,18 @@ function resolveIncludeFile(includeRef, repoRoot, bundleRoot, options = {}) {
   const scopedMatch = trimmed.match(/^([a-z]+):(.*)$/i);
   const scope = scopedMatch?.[1]?.toLowerCase();
   const target = scopedMatch ? scopedMatch[2].trim() : trimmed;
-  const optimaRoot = options.optimaRoot || path2.join(repoRoot, ".optima");
-  const repoPolicyRoot = options.repoPolicyRoot || path2.join(optimaRoot, "policies");
-  const bundlePolicyRoot = options.bundlePolicyRoot || path2.join(bundleRoot, "assets", "policies");
+  const optimaRoot = options.optimaRoot || path4.join(repoRoot, ".optima");
+  const repoPolicyRoot = options.repoPolicyRoot || path4.join(optimaRoot, "policies");
+  const bundlePolicyRoot = options.bundlePolicyRoot || path4.join(bundleRoot, "assets", "policies");
   if (scope === "plugin") {
     for (const filePath of withCompactPreference([resolveWithin(bundleRoot, target)], options)) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
+      if (filePath && fs4.existsSync(filePath)) return filePath;
     }
     return null;
   }
   if (scope === "repo") {
     for (const filePath of withCompactPreference([resolveWithin(optimaRoot, target)], options)) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
+      if (filePath && fs4.existsSync(filePath)) return filePath;
     }
     return null;
   }
@@ -7853,7 +8299,7 @@ function resolveIncludeFile(includeRef, repoRoot, bundleRoot, options = {}) {
       resolveWithin(bundlePolicyRoot, target)
     ], options);
     for (const filePath of candidates2) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
+      if (filePath && fs4.existsSync(filePath)) return filePath;
     }
     return null;
   }
@@ -7862,7 +8308,7 @@ function resolveIncludeFile(includeRef, repoRoot, bundleRoot, options = {}) {
     resolveWithin(bundleRoot, target)
   ], options);
   for (const filePath of candidates) {
-    if (filePath && fs2.existsSync(filePath)) return filePath;
+    if (filePath && fs4.existsSync(filePath)) return filePath;
   }
   return null;
 }
@@ -7883,16 +8329,69 @@ function resolveIncludes(text, repoRoot, bundleRoot, options = {}) {
 
 `;
     }
-    const content = fs2.readFileSync(filePath, "utf8");
+    const content = fs4.readFileSync(filePath, "utf8");
     return resolveIncludes(content, repoRoot, bundleRoot, { ...options, includeDepth: includeDepth + 1, maxIncludeDepth });
   });
 }
 
+// src/markdown_artifacts.js
+import fs5 from "node:fs";
+var CLICKUP_REQUIRED_SUMMARY_SECTIONS = [
+  "Summary",
+  "Work Performed",
+  "AC Coverage",
+  "Verification Results",
+  "Documentation Impact",
+  "Open Risks",
+  "Recommended Next Step"
+];
+var RAW_LOG_SECTION_NAMES = /* @__PURE__ */ new Set(["Raw Logs", "Logs", "Full Logs", "Command Output", "Transcript"]);
+function parseMarkdownSections(markdown = "") {
+  const sections = {};
+  let current = null;
+  let buffer = [];
+  const flush = () => {
+    if (!current) return;
+    sections[current] = buffer.join("\n").trim();
+  };
+  for (const line of String(markdown).split(/\r?\n/)) {
+    const heading = /^(#{2,3})\s+(.+?)\s*$/.exec(line);
+    if (heading) {
+      flush();
+      current = heading[2].trim();
+      buffer = [];
+      continue;
+    }
+    if (current) buffer.push(line);
+  }
+  flush();
+  return sections;
+}
+function parseMarkdownArtifact(markdown = "", { requiredSections = [] } = {}) {
+  const sections = parseMarkdownSections(markdown);
+  const missing = requiredSections.filter((section) => !sections[section]);
+  return {
+    ok: missing.length === 0,
+    sections,
+    missing,
+    message: missing.length ? `Missing required section(s): ${missing.join(", ")}` : "ok"
+  };
+}
+function readMarkdownArtifact(filePath, options = {}) {
+  const markdown = fs5.readFileSync(filePath, "utf8");
+  return parseMarkdownArtifact(markdown, options);
+}
+function stripRawLogSections(sections = {}) {
+  return Object.fromEntries(
+    Object.entries(sections).filter(([name]) => !RAW_LOG_SECTION_NAMES.has(name))
+  );
+}
+
 // src/repair.js
 var import_yaml = __toESM(require_dist(), 1);
 var import_ignore = __toESM(require_ignore(), 1);
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs6 from "node:fs";
+import path5 from "node:path";
 var CODEMAP_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
   ".js",
   ".ts",
@@ -7930,10 +8429,10 @@ var LEGACY_OPERATIONAL_ROOTS = /* @__PURE__ */ new Set([
 ]);
 var OPTIMA_OPERATIONAL_FOLDERS = [".optima", "templates", "dist"];
 function relPath(worktree, targetPath) {
-  return path3.relative(worktree, targetPath).split(path3.sep).join("/") || ".";
+  return path5.relative(worktree, targetPath).split(path5.sep).join("/") || ".";
 }
 function normalizeCodemapRelPath(relPathValue) {
-  return path3.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
+  return path5.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
 }
 function firstPathSegment(relPathValue) {
   return normalizeCodemapRelPath(relPathValue).split("/").filter(Boolean)[0] || "";
@@ -7952,8 +8451,8 @@ function isHiddenTree(relPathValue) {
 function loadGitIgnoreMatcher(worktree) {
   const ig = (0, import_ignore.default)();
   ig.add(".git");
-  const gitignorePath = path3.join(worktree, ".gitignore");
-  if (fs3.existsSync(gitignorePath)) ig.add(fs3.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path5.join(worktree, ".gitignore");
+  if (fs6.existsSync(gitignorePath)) ig.add(fs6.readFileSync(gitignorePath, "utf8"));
   return ig;
 }
 function codemapSectionEntries(value) {
@@ -7972,7 +8471,7 @@ function codemapIndexedPaths(map) {
 }
 function readCodemap(filePath, unresolved, worktree) {
   try {
-    const parsed = import_yaml.default.parse(fs3.readFileSync(filePath, "utf8"));
+    const parsed = import_yaml.default.parse(fs6.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;
@@ -7984,42 +8483,42 @@ function readCodemap(filePath, unresolved, worktree) {
   }
 }
 function writeCodemap(filePath, map) {
-  fs3.writeFileSync(filePath, import_yaml.default.stringify(map), "utf8");
+  fs6.writeFileSync(filePath, import_yaml.default.stringify(map), "utf8");
 }
 function isIgnoredPath(ig, relativePath) {
   const normalized = normalizeCodemapRelPath(relativePath);
   return Boolean(normalized) && ig.ignores(normalized);
 }
 function hasImmediateSourceFile(dirPath, ig, worktree) {
-  if (!fs3.existsSync(dirPath)) return false;
-  for (const item of fs3.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path3.join(dirPath, item.name);
-    const relative = path3.relative(worktree, childPath);
+  if (!fs6.existsSync(dirPath)) return false;
+  for (const item of fs6.readdirSync(dirPath, { withFileTypes: true })) {
+    const childPath = path5.join(dirPath, item.name);
+    const relative = path5.relative(worktree, childPath);
     if (isIgnoredPath(ig, relative) || isOperationalRelPath(relative)) continue;
-    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path3.extname(item.name))) return true;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path5.extname(item.name))) return true;
   }
   return false;
 }
 function containsSource(dirPath, ig, worktree) {
-  if (!fs3.existsSync(dirPath)) return false;
-  const dirRelPath = path3.relative(worktree, dirPath);
+  if (!fs6.existsSync(dirPath)) return false;
+  const dirRelPath = path5.relative(worktree, dirPath);
   if (isOperationalRelPath(dirRelPath) || isHiddenTree(dirRelPath)) return false;
-  for (const item of fs3.readdirSync(dirPath, { withFileTypes: true })) {
-    const childPath = path3.join(dirPath, item.name);
-    const relative = path3.relative(worktree, childPath);
+  for (const item of fs6.readdirSync(dirPath, { withFileTypes: true })) {
+    const childPath = path5.join(dirPath, item.name);
+    const relative = path5.relative(worktree, childPath);
     if (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative)) continue;
-    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path3.extname(item.name))) return true;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path5.extname(item.name))) return true;
     if (item.isDirectory() && containsSource(childPath, ig, worktree)) return true;
   }
   return false;
 }
 function createModuleCodemap(dirPath, worktree, deps) {
-  const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs6.readdirSync(dirPath, { withFileTypes: true });
   const entrypoints = [];
   const internals = [];
-  const relToRoot = path3.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path3.sep).join("/");
+  const relToRoot = path5.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path5.sep).join("/");
   for (const item of entries) {
-    if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path3.extname(item.name))) continue;
+    if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path5.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 });
   }
@@ -8032,7 +8531,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 = path3.dirname(codemapPath);
+  const mapDir = path5.dirname(codemapPath);
   const pathBase = isRootMap ? worktree : mapDir;
   let changed = false;
   for (const section of ["modules", "entrypoints", "sources_of_truth", "links", "internals"]) {
@@ -8043,13 +8542,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://") || path3.isAbsolute(entry.path)) {
+      if (!entry?.path || entry.path.startsWith("http://") || entry.path.startsWith("https://") || path5.isAbsolute(entry.path)) {
         nextEntries.push(entry);
         continue;
       }
       const normalizedPath = normalizeCodemapRelPath(entry.path);
-      const absPath = path3.join(pathBase, normalizedPath);
-      if (!fs3.existsSync(absPath)) {
+      const absPath = path5.join(pathBase, normalizedPath);
+      if (!fs6.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;
@@ -8058,8 +8557,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 = path3.join(pathBase, localPath);
-        if (fs3.existsSync(localAbs)) {
+        const localAbs = path5.join(pathBase, localPath);
+        if (fs6.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}'.` });
@@ -8073,11 +8572,11 @@ function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unres
     }
     if (Array.isArray(map[section])) map[section] = nextEntries;
   }
-  if (map.scope === "module" && !isOperationalRelPath(path3.relative(worktree, mapDir))) {
+  if (map.scope === "module" && !isOperationalRelPath(path5.relative(worktree, mapDir))) {
     const indexed = codemapIndexedPaths(map);
     const internals = Array.isArray(map.internals) ? map.internals : [];
-    for (const item of fs3.readdirSync(mapDir, { withFileTypes: true })) {
-      if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path3.extname(item.name))) continue;
+    for (const item of fs6.readdirSync(mapDir, { withFileTypes: true })) {
+      if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path5.extname(item.name))) continue;
       if (indexed.has(item.name)) continue;
       internals.push({ path: item.name });
       indexed.add(item.name);
@@ -8091,13 +8590,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 = !fs3.existsSync(rootCodemapPath);
+  const rootCodemapMissing = !fs6.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 (fs3.existsSync(rootCodemapPath)) repairSingleCodemap(rootCodemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-  const rootMap = fs3.existsSync(rootCodemapPath) ? readCodemap(rootCodemapPath, unresolved, worktree) : null;
+  if (fs6.existsSync(rootCodemapPath)) repairSingleCodemap(rootCodemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
+  const rootMap = fs6.existsSync(rootCodemapPath) ? readCodemap(rootCodemapPath, unresolved, worktree) : null;
   let rootChanged = false;
   const rootModulesRepairable = rootMap && (rootMap.modules === void 0 || Array.isArray(rootMap.modules));
   if (rootMap) {
@@ -8109,10 +8608,10 @@ function repairCodemaps(worktree, apply, actions, unresolved, deps) {
     }
   }
   function walk(dirPath) {
-    const relative = path3.relative(worktree, dirPath);
+    const relative = path5.relative(worktree, dirPath);
     if (relative && (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative))) return;
-    const codemapPath = path3.join(dirPath, "codemap.yml");
-    const hasCodemap = fs3.existsSync(codemapPath);
+    const codemapPath = path5.join(dirPath, "codemap.yml");
+    const hasCodemap = fs6.existsSync(codemapPath);
     const sourceDir = relative && containsSource(dirPath, ig, worktree);
     if (sourceDir && !hasCodemap && dirPath !== worktree) {
       if (hasImmediateSourceFile(dirPath, ig, worktree)) {
@@ -8131,19 +8630,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 (fs3.existsSync(codemapPath) && codemapPath !== rootCodemapPath) repairSingleCodemap(codemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
-    for (const item of fs3.readdirSync(dirPath, { withFileTypes: true })) {
-      if (item.isDirectory()) walk(path3.join(dirPath, item.name));
+    if (fs6.existsSync(codemapPath) && codemapPath !== rootCodemapPath) repairSingleCodemap(codemapPath, worktree, apply, (action) => actions.push(action), unresolved, deps);
+    for (const item of fs6.readdirSync(dirPath, { withFileTypes: true })) {
+      if (item.isDirectory()) walk(path5.join(dirPath, item.name));
     }
   }
-  if (fs3.existsSync(worktree)) walk(worktree);
+  if (fs6.existsSync(worktree)) walk(worktree);
   if (rootMap && rootChanged && apply) writeCodemap(rootCodemapPath, rootMap);
 }
 function walkMarkdownFiles(dirPath) {
-  if (!fs3.existsSync(dirPath)) return [];
+  if (!fs6.existsSync(dirPath)) return [];
   const files = [];
-  for (const entry of fs3.readdirSync(dirPath, { withFileTypes: true })) {
-    const entryPath = path3.join(dirPath, entry.name);
+  for (const entry of fs6.readdirSync(dirPath, { withFileTypes: true })) {
+    const entryPath = path5.join(dirPath, entry.name);
     if (entry.isDirectory()) {
       files.push(...walkMarkdownFiles(entryPath));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -8182,7 +8681,7 @@ function rewriteOptimaMarkdownReferences(content, evidenceBasePath = null) {
 }
 function optimaEvidenceBaseForFile(worktree, filePath, deps) {
   const evidenceRoot = deps.optimaEvidencesDir(worktree);
-  const relative = path3.relative(evidenceRoot, filePath).split(path3.sep).join("/");
+  const relative = path5.relative(evidenceRoot, filePath).split(path5.sep).join("/");
   const [taskId] = relative.split("/");
   if (!taskId || taskId === ".." || relative.startsWith("../")) return null;
   return `.optima/evidences/${taskId}`;
@@ -8195,11 +8694,11 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
   ];
   const changed = [];
   for (const filePath of scanRoots.flatMap(walkMarkdownFiles)) {
-    const raw = fs3.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path3.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
+    const raw = fs6.readFileSync(filePath, "utf8");
+    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path5.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
     const rewritten = rewriteOptimaMarkdownReferences(raw, evidenceBasePath);
     if (rewritten !== raw) {
-      fs3.writeFileSync(filePath, rewritten, "utf8");
+      fs6.writeFileSync(filePath, rewritten, "utf8");
       changed.push(relPath(worktree, filePath));
     }
   }
@@ -8207,8 +8706,8 @@ function normalizeOptimaMarkdownReferences(worktree, deps) {
 }
 function missingOptimaGitignoreRules(worktree, deps) {
   if (!deps.isGitRepository(worktree)) return [];
-  const gitignorePath = path3.join(worktree, ".gitignore");
-  const existing = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf8") : "";
+  const gitignorePath = path5.join(worktree, ".gitignore");
+  const existing = fs6.existsSync(gitignorePath) ? fs6.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));
 }
@@ -8225,11 +8724,11 @@ function planOptimaRepair(worktree, args = {}, deps) {
   const apply = mode === "apply";
   const actions = [];
   const unresolved = [];
-  const hadOptima = fs3.existsSync(deps.optimaDir(worktree));
+  const hadOptima = fs6.existsSync(deps.optimaDir(worktree));
   const missingGitignoreRules = missingOptimaGitignoreRules(worktree, deps);
   const markdownBefore = apply ? [] : walkMarkdownFiles(deps.optimaDir(worktree)).filter((filePath) => {
-    const raw = fs3.readFileSync(filePath, "utf8");
-    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path3.sep) ? optimaEvidenceBaseForFile(worktree, filePath, deps) : null;
+    const raw = fs6.readFileSync(filePath, "utf8");
+    const evidenceBasePath = filePath.startsWith(deps.optimaEvidencesDir(worktree) + path5.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.");
@@ -8238,31 +8737,31 @@ function planOptimaRepair(worktree, args = {}, deps) {
     [".staticeng/", deps.legacyStaticEngDir(worktree)],
     [".nomadwork/", deps.legacyNomadworkDir(worktree)],
     [".nomadworks/", deps.legacyNomadworksDir(worktree)],
-    ["tasks/", path3.join(worktree, "tasks")],
-    ["evidences/", path3.join(worktree, "evidences")],
-    ["docs/scrs/", path3.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path3.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path3.join(worktree, "codemap.yaml")]
+    ["tasks/", path5.join(worktree, "tasks")],
+    ["evidences/", path5.join(worktree, "evidences")],
+    ["docs/scrs/", path5.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path5.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path5.join(worktree, "codemap.yaml")]
   ];
-  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path3.join(worktree, "policies")]);
+  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path5.join(worktree, "policies")]);
   for (const [display, sourcePath] of legacySources) {
-    if (fs3.existsSync(sourcePath)) pushRepairAction(actions, "legacy", apply ? "migrated" : "would_migrate", display, "Move or merge legacy/root Optima artifact into .optima using preservation safeguards.");
+    if (fs6.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 = !fs3.existsSync(deps.repoConfigPath(worktree));
+  const configMissing = !fs6.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 = [
-    [path3.join(deps.optimaTasksDir(worktree), "current.md"), "registry", ".optima/tasks/current.md", deps.currentTasksRegistryContent()],
-    [path3.join(deps.optimaTasksDir(worktree), "done.md"), "registry", ".optima/tasks/done.md", deps.doneTasksRegistryContent()],
-    [path3.join(deps.optimaScrsDir(worktree), "current.md"), "registry", ".optima/docs/scrs/current.md", deps.currentScrRegistryContent()],
-    [path3.join(deps.optimaScrsDir(worktree), "done.md"), "registry", ".optima/docs/scrs/done.md", deps.doneScrRegistryContent()],
-    [path3.join(deps.optimaTasksDir(worktree), "task-template.md"), "template", ".optima/tasks/task-template.md", deps.taskTemplateContent()],
-    [path3.join(deps.optimaTasksDir(worktree), "subtask-template.md"), "template", ".optima/tasks/subtask-template.md", deps.subtaskTemplateContent()],
-    [path3.join(deps.repoPoliciesDir(worktree), "README.md"), "policy", ".optima/policies/README.md", deps.repoLocalPoliciesReadme]
+    [path5.join(deps.optimaTasksDir(worktree), "current.md"), "registry", ".optima/tasks/current.md", deps.currentTasksRegistryContent()],
+    [path5.join(deps.optimaTasksDir(worktree), "done.md"), "registry", ".optima/tasks/done.md", deps.doneTasksRegistryContent()],
+    [path5.join(deps.optimaScrsDir(worktree), "current.md"), "registry", ".optima/docs/scrs/current.md", deps.currentScrRegistryContent()],
+    [path5.join(deps.optimaScrsDir(worktree), "done.md"), "registry", ".optima/docs/scrs/done.md", deps.doneScrRegistryContent()],
+    [path5.join(deps.optimaTasksDir(worktree), "task-template.md"), "template", ".optima/tasks/task-template.md", deps.taskTemplateContent()],
+    [path5.join(deps.optimaTasksDir(worktree), "subtask-template.md"), "template", ".optima/tasks/subtask-template.md", deps.subtaskTemplateContent()],
+    [path5.join(deps.repoPoliciesDir(worktree), "README.md"), "policy", ".optima/policies/README.md", deps.repoLocalPoliciesReadme]
   ];
   for (const [filePath, category, displayPath, content] of requiredFiles) {
-    if (!fs3.existsSync(filePath)) {
+    if (!fs6.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);
     }
@@ -8316,18 +8815,18 @@ function formatRepairResult(plan, validationResult = null, formatValidationResul
 // src/validate_logic.js
 var import_yaml2 = __toESM(require_dist(), 1);
 var import_ignore2 = __toESM(require_ignore(), 1);
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs7 from "node:fs";
+import path6 from "node:path";
 async function optima_validate_logic(worktree) {
-  const rootCodemapPath = path4.join(worktree, ".optima", "codemap.yml");
-  if (!fs4.existsSync(rootCodemapPath)) return { ok: false, errors: [".optima/codemap.yml not found."], warnings: [] };
+  const rootCodemapPath = path6.join(worktree, ".optima", "codemap.yml");
+  if (!fs7.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 = path4.join(worktree, ".gitignore");
-  if (fs4.existsSync(gitignorePath)) {
-    ig.add(fs4.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path6.join(worktree, ".gitignore");
+  if (fs7.existsSync(gitignorePath)) {
+    ig.add(fs7.readFileSync(gitignorePath, "utf8"));
   }
   const sourceExtensions = [
     ".js",
@@ -8367,30 +8866,30 @@ async function optima_validate_logic(worktree) {
   const operationalFolders = [".optima", "templates", "dist"];
   const isHiddenTree2 = (relPath2) => {
     if (!relPath2) return false;
-    return relPath2.split(path4.sep).some((part) => part.startsWith("."));
+    return relPath2.split(path6.sep).some((part) => part.startsWith("."));
   };
-  const firstPathSegment2 = (relPath2) => relPath2.split(path4.sep).filter(Boolean)[0] || "";
+  const firstPathSegment2 = (relPath2) => relPath2.split(path6.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 + path4.sep));
+    return operationalFolders.some((f) => relPath2 === f || relPath2.startsWith(f + path6.sep));
   };
   const getSectionEntries = (value) => {
     if (Array.isArray(value)) return value;
     if (value && typeof value === "object") return Object.values(value);
     return [];
   };
-  const normalizeRelativePath = (relPath2) => path4.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizeRelativePath = (relPath2) => path6.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
   const isSourceDir = (dirPath) => {
-    const dirRelPath = path4.relative(worktree, dirPath);
+    const dirRelPath = path6.relative(worktree, dirPath);
     if (isOperationalRelPath2(dirRelPath)) return false;
-    const items = fs4.readdirSync(dirPath, { withFileTypes: true });
+    const items = fs7.readdirSync(dirPath, { withFileTypes: true });
     for (const item of items) {
-      const childPath = path4.join(dirPath, item.name);
-      const relPath2 = path4.relative(worktree, childPath);
+      const childPath = path6.join(dirPath, item.name);
+      const relPath2 = path6.relative(worktree, childPath);
       if (ig.ignores(relPath2) || isOperationalRelPath2(relPath2)) continue;
-      if (item.isFile() && sourceExtensions.includes(path4.extname(item.name))) return true;
+      if (item.isFile() && sourceExtensions.includes(path6.extname(item.name))) return true;
       if (item.isDirectory()) {
         if (isSourceDir(childPath)) return true;
       }
@@ -8398,7 +8897,7 @@ async function optima_validate_logic(worktree) {
     return false;
   };
   function validateMap(filePath) {
-    const content = fs4.readFileSync(filePath, "utf8");
+    const content = fs7.readFileSync(filePath, "utf8");
     let map;
     try {
       map = import_yaml2.default.parse(content);
@@ -8410,32 +8909,32 @@ async function optima_validate_logic(worktree) {
       errors.push(`${filePath}: Invalid YAML.`);
       return;
     }
-    const dir = path4.dirname(filePath);
+    const dir = path6.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(path4.normalize(item.path));
+          indexedPaths.add(path6.normalize(item.path));
           if (section === "links" && (item.path.startsWith("http://") || item.path.startsWith("https://"))) {
             continue;
           }
-          const absPath = path4.isAbsolute(item.path) ? item.path : path4.join(pathBase, item.path);
-          if (!fs4.existsSync(absPath)) {
+          const absPath = path6.isAbsolute(item.path) ? item.path : path6.join(pathBase, item.path);
+          if (!fs7.existsSync(absPath)) {
             errors.push(`${filePath}: ${section.slice(0, -1)} path does not exist: ${item.path}`);
           }
         }
       }
     }
-    const relDir = path4.relative(worktree, dir);
+    const relDir = path6.relative(worktree, dir);
     const isOperational = isOperationalRelPath2(relDir);
     if (map.scope === "module" && !isOperational) {
-      const items = fs4.readdirSync(dir, { withFileTypes: true });
+      const items = fs7.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (item.isFile() && sourceExtensions.includes(path4.extname(item.name))) {
+        if (item.isFile() && sourceExtensions.includes(path6.extname(item.name))) {
           if (item.name === "codemap.yml") continue;
-          if (!indexedPaths.has(path4.normalize(item.name))) {
+          if (!indexedPaths.has(path6.normalize(item.name))) {
             errors.push(`${filePath}: Unindexed source file found: '${item.name}'. Every source file must be categorized in a section (e.g., 'internals').`);
           }
         }
@@ -8445,7 +8944,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 (path4.isAbsolute(entry.path)) continue;
+        if (path6.isAbsolute(entry.path)) continue;
         const normalizedPath = normalizeRelativePath(entry.path);
         if (!normalizedPath || normalizedPath === ".") continue;
         const parts = normalizedPath.split("/").filter((p) => p && p !== ".");
@@ -8457,18 +8956,18 @@ async function optima_validate_logic(worktree) {
     }
   }
   const walk = (dir) => {
-    const relDir = path4.relative(worktree, dir);
+    const relDir = path6.relative(worktree, dir);
     if (relDir && ig.ignores(relDir)) return;
     if (isOperationalRelPath2(relDir)) return;
     if (isHiddenTree2(relDir)) return;
-    const hasCodemap = fs4.existsSync(path4.join(dir, "codemap.yml"));
-    const items = fs4.readdirSync(dir, { withFileTypes: true });
-    if (!relDir.startsWith(path4.join(".optima", "tasks", "done"))) {
+    const hasCodemap = fs7.existsSync(path6.join(dir, "codemap.yml"));
+    const items = fs7.readdirSync(dir, { withFileTypes: true });
+    if (!relDir.startsWith(path6.join(".optima", "tasks", "done"))) {
       for (const item of items) {
         if (item.isFile() && item.name.endsWith(".md")) {
-          const content = fs4.readFileSync(path4.join(dir, item.name), "utf8");
+          const content = fs7.readFileSync(path6.join(dir, item.name), "utf8");
           if (content.includes("[To be defined]") || content.includes("[Insert ")) {
-            const relFilePath = path4.join(relDir, item.name);
+            const relFilePath = path6.join(relDir, item.name);
             errors.push(`Documentation Placeholder found: '${relFilePath}' still contains [To be defined] or [Insert ...] placeholders.`);
           }
         }
@@ -8478,9 +8977,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(path4.join(dir, "codemap.yml"));
+    if (hasCodemap) validateMap(path6.join(dir, "codemap.yml"));
     for (const item of items) {
-      if (item.isDirectory()) walk(path4.join(dir, item.name));
+      if (item.isDirectory()) walk(path6.join(dir, item.name));
     }
   };
   validateMap(rootCodemapPath);
@@ -8493,14 +8992,14 @@ async function optima_validate_logic(worktree) {
 }
 
 // src/constants.js
-import path5 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
-var PKG_ROOT = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "..");
-var BUNDLE_ASSETS_DIR = path5.join(PKG_ROOT, "assets");
-var BUNDLE_AGENTS_DIR = path5.join(BUNDLE_ASSETS_DIR, "agents");
-var BUNDLE_POLICIES_DIR = path5.join(BUNDLE_ASSETS_DIR, "policies");
-var TEMPLATES_DIR = path5.join(PKG_ROOT, "templates");
-var HUMANS_REGISTRY_PATH = path5.join(PKG_ROOT, "docs", "core", "humans.md");
+var PKG_ROOT = path7.resolve(path7.dirname(fileURLToPath(import.meta.url)), "..");
+var BUNDLE_ASSETS_DIR = path7.join(PKG_ROOT, "assets");
+var BUNDLE_AGENTS_DIR = path7.join(BUNDLE_ASSETS_DIR, "agents");
+var BUNDLE_POLICIES_DIR = path7.join(BUNDLE_ASSETS_DIR, "policies");
+var TEMPLATES_DIR = path7.join(PKG_ROOT, "templates");
+var HUMANS_REGISTRY_PATH = path7.join(PKG_ROOT, "docs", "core", "humans.md");
 var MANDATORY_AGENTS = /* @__PURE__ */ new Set(["product_manager", "business_analyst", "tech_lead"]);
 var MINI_MODE_AGENTS = /* @__PURE__ */ new Set(["product_manager", "business_analyst", "tech_lead"]);
 var CLICKUP_IGNORED_TASK_TYPES = ["Idea", "Backlog", "Hito", "Nota de reuni\xF3n", "Respuesta del formulario"];
@@ -8638,18 +9137,18 @@ var GITHUB_WEBHOOK_EVENTS = ["pull_request", "pull_request_review", "pull_reques
 var OPTIMA_GITHUB_COMMITTER_NAME = "Optima Product Manager";
 var OPTIMA_GITHUB_COMMITTER_EMAIL = "optima-product-manager[bot]@users.noreply.github.com";
 function isRootDirectory(candidate) {
-  const resolved = path6.resolve(candidate);
-  return resolved === path6.parse(resolved).root;
+  const resolved = path8.resolve(candidate);
+  return resolved === path8.parse(resolved).root;
 }
 function isSafeWritableDirectory(candidate) {
   if (typeof candidate !== "string" || !candidate.trim()) return false;
-  if (!path6.isAbsolute(candidate)) return false;
-  const resolved = path6.resolve(candidate);
+  if (!path8.isAbsolute(candidate)) return false;
+  const resolved = path8.resolve(candidate);
   if (isRootDirectory(resolved)) return false;
   try {
-    const stat = fs5.statSync(resolved);
+    const stat = fs8.statSync(resolved);
     if (!stat.isDirectory()) return false;
-    fs5.accessSync(resolved, fs5.constants.W_OK);
+    fs8.accessSync(resolved, fs8.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -8661,11 +9160,11 @@ function resolveSafeWorktree(context = {}, pluginWorktree = null) {
     context?.directory,
     pluginWorktree,
     process.cwd(),
-    os.homedir()
+    os2.homedir()
   ];
   for (const candidate of candidates) {
     if (typeof candidate !== "string" || !candidate.trim()) continue;
-    const resolved = path6.resolve(candidate);
+    const resolved = path8.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   throw new Error(SAFE_WORKTREE_FAILURE);
@@ -8680,13 +9179,13 @@ function safeWorktreeOrFailure(context, pluginWorktree) {
 function explicitSafeInputWorktree(input = {}) {
   for (const candidate of [input?.worktree, input?.directory]) {
     if (typeof candidate !== "string" || !candidate.trim()) continue;
-    const resolved = path6.resolve(candidate);
+    const resolved = path8.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   return null;
 }
 function isGitRepository(worktree) {
-  return fs5.existsSync(path6.join(worktree, ".git"));
+  return fs8.existsSync(path8.join(worktree, ".git"));
 }
 function normalizeLooseToken(value) {
   return String(value ?? "").trim().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -8720,8 +9219,8 @@ function parseHumansRegistry(markdown = "") {
   return roles;
 }
 function loadHumansRegistry(registryPath = HUMANS_REGISTRY_PATH) {
-  if (!fs5.existsSync(registryPath)) return {};
-  return parseHumansRegistry(fs5.readFileSync(registryPath, "utf8"));
+  if (!fs8.existsSync(registryPath)) return {};
+  return parseHumansRegistry(fs8.readFileSync(registryPath, "utf8"));
 }
 function resolveHumanRoles(roles = CLICKUP_FINAL_APPROVER_ROLES, registry = loadHumansRegistry()) {
   return [...new Set(roles.map((role) => registry[String(role ?? "").trim()] || "").filter(Boolean))];
@@ -8893,78 +9392,28 @@ function buildClickUpReviewAutomationPlan({ isSubtask = false, humanApprover = "
     }
   };
 }
-function validateMainWorkspaceBranchSafety({ currentBranch, requiredBranch = "dev", forbiddenBranch = "main" } = {}) {
-  const normalized = String(currentBranch ?? "").trim();
-  if (!normalized) {
-    return { ok: false, branch: normalized, message: "Unable to determine the current branch; expected main workspace on dev." };
-  }
-  if (normalized === forbiddenBranch) {
-    return { ok: false, branch: normalized, message: "Unsafe workspace branch: main is never allowed for Optima delivery work." };
-  }
-  if (normalized !== requiredBranch) {
-    return { ok: false, branch: normalized, message: `Unsafe workspace branch: expected ${requiredBranch}, got ${normalized}.` };
-  }
-  return { ok: true, branch: normalized, message: `Workspace branch is safe on ${requiredBranch}.` };
-}
-var CLICKUP_REQUIRED_SUMMARY_SECTIONS = [
-  "Summary",
-  "Work Performed",
-  "AC Coverage",
-  "Verification Results",
-  "Documentation Impact",
-  "Open Risks",
-  "Recommended Next Step"
-];
-var CLICKUP_RAW_LOG_SECTION_NAMES = /* @__PURE__ */ new Set(["Raw Logs", "Logs", "Full Logs", "Command Output", "Transcript"]);
-var CLICKUP_TRANSITIONS = /* @__PURE__ */ new Map([
-  ["plan->in progress", { status: "in progress", comment: "Plan complete; moving to implementation without generic CTO/PO assignment." }],
-  ["in progress->validation", { status: "validation", comment: "Implementation complete; ready for validation." }],
-  ["validation->merge", { status: "merge", assignFinalApprovers: true, parentOnlyFinalApproval: true, comment: "Parent validation passed with a functional preview URL; ready for CTO/PO approval flow." }],
-  ["validation->in progress", { status: "in progress", comment: "Validation failed; returning to implementation." }],
-  ["merge->completed", { status: "completed", comment: "Merge complete; closing delivery task." }],
-  ["completed->in progress", { status: "in progress", comment: "Task reopened; returning to implementation." }],
-  ["closed->in progress", { status: "in progress", comment: "Task reopened; returning to implementation." }]
-]);
-function parseMarkdownSections(markdown = "") {
-  const sections = {};
-  let current = null;
-  let buffer = [];
-  const flush = () => {
-    if (!current) return;
-    sections[current] = buffer.join("\n").trim();
-  };
-  for (const line of String(markdown).split(/\r?\n/)) {
-    const heading = /^(#{2,3})\s+(.+?)\s*$/.exec(line);
-    if (heading) {
-      flush();
-      current = heading[2].trim();
-      buffer = [];
-      continue;
-    }
-    if (current) buffer.push(line);
-  }
-  flush();
-  return sections;
-}
-function parseMarkdownArtifact(markdown = "", { requiredSections = [] } = {}) {
-  const sections = parseMarkdownSections(markdown);
-  const missing = requiredSections.filter((section) => !sections[section]);
-  return {
-    ok: missing.length === 0,
-    sections,
-    missing,
-    message: missing.length ? `Missing required section(s): ${missing.join(", ")}` : "ok"
-  };
-}
-function readMarkdownArtifact(filePath, options = {}) {
-  const markdown = fs5.readFileSync(filePath, "utf8");
-  return parseMarkdownArtifact(markdown, options);
-}
-function stripRawLogSections(sections = {}) {
-  return Object.fromEntries(
-    Object.entries(sections).filter(([name]) => !CLICKUP_RAW_LOG_SECTION_NAMES.has(name))
-  );
+function validateMainWorkspaceBranchSafety({ currentBranch, requiredBranch = "dev", forbiddenBranch = "main" } = {}) {
+  const normalized = String(currentBranch ?? "").trim();
+  if (!normalized) {
+    return { ok: false, branch: normalized, message: "Unable to determine the current branch; expected main workspace on dev." };
+  }
+  if (normalized === forbiddenBranch) {
+    return { ok: false, branch: normalized, message: "Unsafe workspace branch: main is never allowed for Optima delivery work." };
+  }
+  if (normalized !== requiredBranch) {
+    return { ok: false, branch: normalized, message: `Unsafe workspace branch: expected ${requiredBranch}, got ${normalized}.` };
+  }
+  return { ok: true, branch: normalized, message: `Workspace branch is safe on ${requiredBranch}.` };
 }
+var CLICKUP_TRANSITIONS = /* @__PURE__ */ new Map([
+  ["plan->in progress", { status: "in progress", comment: "Plan complete; moving to implementation without generic CTO/PO assignment." }],
+  ["in progress->validation", { status: "validation", comment: "Implementation complete; ready for validation." }],
+  ["validation->merge", { status: "merge", assignFinalApprovers: true, parentOnlyFinalApproval: true, comment: "Parent validation passed with a functional preview URL; ready for CTO/PO approval flow." }],
+  ["validation->in progress", { status: "in progress", comment: "Validation failed; returning to implementation." }],
+  ["merge->completed", { status: "completed", comment: "Merge complete; closing delivery task." }],
+  ["completed->in progress", { status: "in progress", comment: "Task reopened; returning to implementation." }],
+  ["closed->in progress", { status: "in progress", comment: "Task reopened; returning to implementation." }]
+]);
 var CLICKUP_SUBTASK_REQUIRED_FIELDS = ["Type", "Owner Role", "Story Points", "Slice", "Acceptance Criteria"];
 var CLICKUP_SUBTASK_OPTIONAL_FIELDS = ["Depends On", "Branch", "Description", "Definition", "Documentation"];
 var CLICKUP_SUBTASK_KNOWN_FIELDS = /* @__PURE__ */ new Set([...CLICKUP_SUBTASK_REQUIRED_FIELDS, ...CLICKUP_SUBTASK_OPTIONAL_FIELDS]);
@@ -9168,7 +9617,7 @@ function buildClickUpApplyPayloadResult({ payload, apply = false } = {}) {
       noop: true,
       applied: false,
       message: "Dry-run only. Payload validated; no ClickUp calls were made.",
-      payload: parsed
+      payload: normalizeClickUpPayloadComments(parsed)
     };
   }
   return {
@@ -9178,7 +9627,7 @@ function buildClickUpApplyPayloadResult({ payload, apply = false } = {}) {
     applyRequested: true,
     applied: false,
     message: "Live ClickUp execution is not implemented/configured in this safe boundary; no ClickUp calls were made.",
-    payload: parsed
+    payload: normalizeClickUpPayloadComments(parsed)
   };
 }
 function sectionValue(sections, names) {
@@ -9188,7 +9637,7 @@ function sectionValue(sections, names) {
   return "";
 }
 function compactMarkdownValue(value = "") {
-  return String(value).split(/\r?\n/).map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  return normalizeClickUpMarkdown(value);
 }
 function buildClickUpSummaryPayload({ summaryMarkdown = "", summaryPath = "", taskMarkdown = "", taskPath = "", branch = "", worktree = "", pr = "" } = {}) {
   const parsedSummary = parseMarkdownArtifact(summaryMarkdown, { requiredSections: CLICKUP_REQUIRED_SUMMARY_SECTIONS });
@@ -9213,13 +9662,12 @@ function buildClickUpSummaryPayload({ summaryMarkdown = "", summaryPath = "", ta
     deliveryPath ? `- Delivery evidence: ${compactMarkdownValue(deliveryPath)}` : null,
     prValue ? `- PR: ${compactMarkdownValue(prValue)}` : null
   ].filter(Boolean);
-  const comment = [
-    "ClickUp sync payload generated from Optima Markdown artifacts.",
-    "",
-    ...commentParts.flatMap(([title, value]) => [`## ${title}`, compactMarkdownValue(value) || "Not specified.", ""]),
-    contextParts.length ? "## PR/Branch/Worktree" : null,
-    contextParts.length ? contextParts.join("\n") : null
-  ].filter((part) => part !== null).join("\n").trim();
+  const comment = formatClickUpStatusComment({
+    title: "Optima Delivery Summary",
+    summary: "ClickUp sync payload generated from Optima Markdown artifacts.",
+    sections: commentParts.map(([title, value]) => ({ title, body: compactMarkdownValue(value) || "Not specified." })),
+    context: contextParts
+  });
   return {
     ok: true,
     mode: "payload",
@@ -9245,7 +9693,7 @@ function buildClickUpSummaryPayload({ summaryMarkdown = "", summaryPath = "", ta
 function deriveClickUpWorktree({ baseWorktree = "", taskId, taskType, parentTaskId, subtaskId } = {}) {
   const branch = deriveClickUpBranchName({ taskType, parentTaskId, subtaskId, taskId });
   const root = baseWorktree || process.cwd();
-  return path6.join(path6.dirname(root), `${path6.basename(root)}-${branch.replace(/\//g, "-")}`);
+  return path8.join(path8.dirname(root), `${path8.basename(root)}-${branch.replace(/\//g, "-")}`);
 }
 function clickUpCustomFieldValue(task = {}, names = []) {
   const fields = Array.isArray(task.custom_fields) ? task.custom_fields : [];
@@ -9269,12 +9717,12 @@ function safeExistingClickUpWorktree({ metadata = {}, branch = "" } = {}) {
   const taskMetadata = metadataTaskRouting(metadata);
   const existingWorktree = typeof taskMetadata.worktree === "string" ? taskMetadata.worktree.trim() : "";
   const existingBranch = typeof taskMetadata.branch === "string" ? taskMetadata.branch.trim() : "";
-  if (!existingWorktree || !path6.isAbsolute(existingWorktree) || !fs5.existsSync(existingWorktree)) return null;
+  if (!existingWorktree || !path8.isAbsolute(existingWorktree) || !fs8.existsSync(existingWorktree)) return null;
   try {
-    const stat = fs5.statSync(existingWorktree);
+    const stat = fs8.statSync(existingWorktree);
     if (!stat.isDirectory()) return null;
     if (branch && existingBranch && existingBranch !== branch) return null;
-    return { branch: existingBranch || branch, worktree: path6.resolve(existingWorktree), reused: true };
+    return { branch: existingBranch || branch, worktree: path8.resolve(existingWorktree), reused: true };
   } catch {
     return null;
   }
@@ -9308,7 +9756,7 @@ function normalizeOptimaGitIdentity(identity = {}) {
   };
 }
 function configureOptimaWorktreeGitIdentity({ worktreePath, identity = {}, runGitFn = runGit } = {}) {
-  if (!worktreePath || !fs5.existsSync(worktreePath)) return { configured: false, reason: "worktree_missing" };
+  if (!worktreePath || !fs8.existsSync(worktreePath)) return { configured: false, reason: "worktree_missing" };
   const normalized = normalizeOptimaGitIdentity(identity);
   if (!normalized.name || !normalized.email) return { configured: false, reason: "identity_missing" };
   try {
@@ -9394,17 +9842,17 @@ function openChamberEntryBranch(entry) {
   return String(entry?.branch || entry?.branchName || entry?.branch_name || entry?.worktree?.branch || "").replace(/^refs\/heads\//, "");
 }
 function openChamberListIncludesDirectory(list, directory) {
-  const resolved = path6.resolve(directory);
+  const resolved = path8.resolve(directory);
   return normalizeOpenChamberCollection(list).some((entry) => {
     const entryDirectory = openChamberEntryDirectory(entry);
-    return entryDirectory && path6.resolve(entryDirectory) === resolved;
+    return entryDirectory && path8.resolve(entryDirectory) === resolved;
   });
 }
 function openChamberListIncludesBranch(list, directory, branch) {
-  const resolved = path6.resolve(directory);
+  const resolved = path8.resolve(directory);
   return normalizeOpenChamberCollection(list).some((entry) => {
     const entryDirectory = openChamberEntryDirectory(entry);
-    if (!entryDirectory || path6.resolve(entryDirectory) !== resolved) return false;
+    if (!entryDirectory || path8.resolve(entryDirectory) !== resolved) return false;
     const entryBranch = openChamberEntryBranch(entry);
     return !entryBranch || entryBranch === branch;
   });
@@ -9412,8 +9860,8 @@ function openChamberListIncludesBranch(list, directory, branch) {
 async function findOpenChamberProject({ opencodeBaseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
   const projects = await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: "/project", directory: baseWorktree, fetchImpl });
   if (!Array.isArray(projects)) return null;
-  const resolvedBase = path6.resolve(baseWorktree);
-  return projects.find((project) => path6.resolve(String(project?.worktree || project?.path || "")) === resolvedBase) || null;
+  const resolvedBase = path8.resolve(baseWorktree);
+  return projects.find((project) => path8.resolve(String(project?.worktree || project?.path || "")) === resolvedBase) || null;
 }
 async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, projectId, fetchImpl = globalThis.fetch } = {}) {
   if (!projectId) return { refreshed: false, reason: "project_id_unavailable" };
@@ -9468,18 +9916,18 @@ async function createOpenChamberClickUpWorktree({ openchamberBaseUrl, baseUrl, b
   }
   const createdDirectory = openChamberEntryDirectory(created);
   const createdBranch = openChamberEntryBranch(created);
-  if (!createdDirectory || !path6.isAbsolute(createdDirectory)) {
+  if (!createdDirectory || !path8.isAbsolute(createdDirectory)) {
     throw new Error(`OpenChamber did not return an absolute worktree path for ${branch}.`);
   }
   if (createdBranch !== branch) {
     throw new Error(`OpenChamber created unexpected branch ${createdBranch || "<unknown>"}; expected ${branch}.`);
   }
   const verified = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath: createdDirectory, branch, fetchImpl });
-  return { created, worktree: path6.resolve(createdDirectory), branch: createdBranch, verified };
+  return { created, worktree: path8.resolve(createdDirectory), branch: createdBranch, verified };
 }
 async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
   const visibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: openchamberBaseUrl || baseUrl, opencodeBaseUrl: opencodeBaseUrl || baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
-  return { branch, worktree: path6.resolve(worktreePath), reused: true, provider: "openchamber", openChamber: { source, visibility } };
+  return { branch, worktree: path8.resolve(worktreePath), reused: true, provider: "openchamber", openChamber: { source, visibility } };
 }
 async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, openchamberBaseUrl = "", opencodeBaseUrl = "", baseUrl = "", fetchImpl = globalThis.fetch, log = null, gitIdentity = {} } = {}) {
   const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
@@ -9497,7 +9945,7 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId,
     return { ...registered, parentBranch: parentBranch || void 0, prTarget, gitIdentity: identity2 };
   }
   const worktreePath = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
-  if (fs5.existsSync(worktreePath)) {
+  if (fs8.existsSync(worktreePath)) {
     const registered = await registerOpenChamberClickUpWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, baseWorktree, branch, worktreePath, fetchImpl, source: "existing_directory" });
     const identity2 = configureOptimaWorktreeGitIdentity({ worktreePath: registered.worktree, identity: gitIdentity, runGitFn });
     log?.({ type: "openchamber_worktree_registered", taskId, branch, worktree: registered.worktree, source: "existing_directory", visibility: registered.openChamber.visibility });
@@ -9506,7 +9954,7 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId,
   let parentBootstrap = null;
   if (isSubtask) {
     const parentWorktree = deriveClickUpWorktree({ baseWorktree, taskId: effectiveParent, taskType, parentTaskId: effectiveParent });
-    if (fs5.existsSync(parentWorktree)) {
+    if (fs8.existsSync(parentWorktree)) {
       const registeredParent = await registerOpenChamberClickUpWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, fetchImpl, source: "parent_existing_directory" });
       const parentIdentity = configureOptimaWorktreeGitIdentity({ worktreePath: registeredParent.worktree, identity: gitIdentity, runGitFn });
       parentBootstrap = { branch: parentBranch, worktree: registeredParent.worktree, reused: true, provider: "openchamber", visibility: registeredParent.openChamber.visibility };
@@ -9549,33 +9997,33 @@ function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tare
   const existing = safeExistingClickUpWorktree({ metadata: existingMetadata, branch });
   if (existing) return { ...existing, branch, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", gitIdentity: configureOptimaWorktreeGitIdentity({ worktreePath: existing.worktree, identity: gitIdentity, runGitFn }) };
   const worktreePath = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
-  if (fs5.existsSync(worktreePath)) {
-    const resolvedWorktree2 = path6.resolve(worktreePath);
+  if (fs8.existsSync(worktreePath)) {
+    const resolvedWorktree2 = path8.resolve(worktreePath);
     return { branch, worktree: resolvedWorktree2, reused: true, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", gitIdentity: configureOptimaWorktreeGitIdentity({ worktreePath: resolvedWorktree2, identity: gitIdentity, runGitFn }) };
   }
   if (allowNonGitFallback) {
-    fs5.mkdirSync(worktreePath, { recursive: true });
-    return { branch, worktree: path6.resolve(worktreePath), reused: false, fallback: "non_git", parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", startPoint: parentBranch || "dev" };
+    fs8.mkdirSync(worktreePath, { recursive: true });
+    return { branch, worktree: path8.resolve(worktreePath), reused: false, fallback: "non_git", parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", startPoint: parentBranch || "dev" };
   }
   let parentBootstrap = null;
   if (isSubtask) {
     const parentWorktree = deriveClickUpWorktree({ baseWorktree, taskId: effectiveParent, taskType, parentTaskId: effectiveParent });
-    if (!fs5.existsSync(parentWorktree)) {
+    if (!fs8.existsSync(parentWorktree)) {
       const parentStartPoint = resolveClickUpDevStartPoint(baseWorktree, runGitFn);
       const parentBranchExists = clickUpGitRefExists(baseWorktree, parentBranch, runGitFn);
       addClickUpWorktreeForBranch({ baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, runGitFn });
-      parentBootstrap = { branch: parentBranch, worktree: path6.resolve(parentWorktree), startPoint: parentBranchExists ? parentBranch : parentStartPoint, reused: parentBranchExists };
+      parentBootstrap = { branch: parentBranch, worktree: path8.resolve(parentWorktree), startPoint: parentBranchExists ? parentBranch : parentStartPoint, reused: parentBranchExists };
       const parentIdentity = configureOptimaWorktreeGitIdentity({ worktreePath: parentBootstrap.worktree, identity: gitIdentity, runGitFn });
       if (parentIdentity.configured) parentBootstrap.gitIdentity = parentIdentity;
     } else {
-      parentBootstrap = { branch: parentBranch, worktree: path6.resolve(parentWorktree), reused: true };
+      parentBootstrap = { branch: parentBranch, worktree: path8.resolve(parentWorktree), reused: true };
       const parentIdentity = configureOptimaWorktreeGitIdentity({ worktreePath: parentBootstrap.worktree, identity: gitIdentity, runGitFn });
       if (parentIdentity.configured) parentBootstrap.gitIdentity = parentIdentity;
     }
   }
   const startPoint = isSubtask ? parentBranch : resolveClickUpDevStartPoint(baseWorktree, runGitFn);
   addClickUpWorktreeForBranch({ baseWorktree, branch, worktreePath, startPoint, runGitFn });
-  const resolvedWorktree = path6.resolve(worktreePath);
+  const resolvedWorktree = path8.resolve(worktreePath);
   return { branch, worktree: resolvedWorktree, reused: false, startPoint, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", parentBootstrap: parentBootstrap || void 0, gitIdentity: configureOptimaWorktreeGitIdentity({ worktreePath: resolvedWorktree, identity: gitIdentity, runGitFn }) };
 }
 function normalizeClickUpDefinitionDocParent(parent = {}) {
@@ -9658,7 +10106,17 @@ function buildClickUpStartTaskPayload({ taskId, taskType = "Tarea", parentTaskId
       wouldCreate: true
     },
     clickup: {
-      comment: `Starting task from ${startFrom}. Branch: ${branch}. Worktree: ${worktree}. Validation PR target: ${requiredPullRequest.targetBranch}. Delivery evidence: ${deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent)}.`,
+      comment: formatClickUpStatusComment({
+        title: "Task Workspace Ready",
+        summary: "Optima prepared the task workspace and validation target.",
+        context: [
+          `Branch: ${branch}`,
+          `Start from: ${startFrom}`,
+          `Worktree: ${worktree}`,
+          `Validation PR target: ${requiredPullRequest.targetBranch}`,
+          `Delivery evidence: ${deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent)}`
+        ]
+      }),
       description,
       fields: {
         Definition: definitionContent,
@@ -9744,7 +10202,18 @@ function buildClickUpTransitionPayload({ fromStatus, toStatus, validationPassed
         remove: removalTargets,
         objective: assignsFinalApprovers ? "zero_product_manager_assigned_tasks" : "preserve_existing_owner_policy"
       },
-      comment: rule.comment,
+      comment: formatClickUpStatusComment({
+        title: "Workflow Status Update",
+        summary: rule.comment,
+        context: [
+          `From: ${from}`,
+          `To: ${rule.status}`,
+          requiredPullRequest?.prUrl ? `PR: ${requiredPullRequest.prUrl}` : null,
+          requiredPullRequest?.prNumber ? `PR number: ${requiredPullRequest.prNumber}` : null,
+          requiredPullRequest?.sourceBranch ? `Source branch: ${requiredPullRequest.sourceBranch}` : null,
+          requiredPullRequest?.targetBranch ? `Target branch: ${requiredPullRequest.targetBranch}` : null
+        ].filter(Boolean)
+      }),
       description,
       fields,
       definition_doc: definitionContent ? {
@@ -9757,8 +10226,8 @@ function buildClickUpTransitionPayload({ fromStatus, toStatus, validationPassed
 }
 function ensureOptimaGitignoreRules(worktree) {
   if (!isGitRepository(worktree)) return { touched: false, added: [] };
-  const gitignorePath = path6.join(worktree, ".gitignore");
-  const existing = fs5.existsSync(gitignorePath) ? fs5.readFileSync(gitignorePath, "utf8") : "";
+  const gitignorePath = path8.join(worktree, ".gitignore");
+  const existing = fs8.existsSync(gitignorePath) ? fs8.readFileSync(gitignorePath, "utf8") : "";
   const existingRules = new Set(existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
   const missingRules = OPTIMA_GITIGNORE_RULES.filter((rule) => !existingRules.has(rule));
   if (missingRules.length === 0) return { touched: false, added: [] };
@@ -9768,45 +10237,45 @@ function ensureOptimaGitignoreRules(worktree) {
     "# Optima local/private state",
     ...missingRules
   ].join("\n");
-  fs5.writeFileSync(gitignorePath, `${existing}${prefix}${separator}${block}
+  fs8.writeFileSync(gitignorePath, `${existing}${prefix}${separator}${block}
 `, "utf8");
   return { touched: true, added: missingRules };
 }
 function optimaDir(worktree) {
-  return path6.join(worktree, OPTIMA_DIRNAME);
+  return path8.join(worktree, OPTIMA_DIRNAME);
 }
 function optimaLocalConfigDir(worktree) {
-  return path6.join(optimaDir(worktree), ".config");
+  return path8.join(optimaDir(worktree), ".config");
 }
 function optimaConfigDir(worktree) {
   return optimaLocalConfigDir(worktree);
 }
 function optimaCodemapPath(worktree) {
-  return path6.join(optimaDir(worktree), "codemap.yml");
+  return path8.join(optimaDir(worktree), "codemap.yml");
 }
 function optimaTasksDir(worktree) {
-  return path6.join(optimaDir(worktree), "tasks");
+  return path8.join(optimaDir(worktree), "tasks");
 }
 function optimaEvidencesDir(worktree) {
-  return path6.join(optimaDir(worktree), "evidences");
+  return path8.join(optimaDir(worktree), "evidences");
 }
 function optimaScrsDir(worktree) {
-  return path6.join(optimaDir(worktree), "docs", "scrs");
+  return path8.join(optimaDir(worktree), "docs", "scrs");
 }
 function legacyNomadworkDir(worktree) {
-  return path6.join(worktree, LEGACY_NOMADWORK_DIRNAME);
+  return path8.join(worktree, LEGACY_NOMADWORK_DIRNAME);
 }
 function legacyNomadworksDir(worktree) {
-  return path6.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
+  return path8.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
 }
 function legacyOrbitaDir(worktree) {
-  return path6.join(worktree, LEGACY_ORBITA_DIRNAME);
+  return path8.join(worktree, LEGACY_ORBITA_DIRNAME);
 }
 function legacyStaticEngDir(worktree) {
-  return path6.join(worktree, LEGACY_STATICENG_DIRNAME);
+  return path8.join(worktree, LEGACY_STATICENG_DIRNAME);
 }
 function repoConfigPath(worktree) {
-  return path6.join(optimaConfigDir(worktree), "optima.yaml");
+  return path8.join(optimaConfigDir(worktree), "optima.yaml");
 }
 function normalizeLegacyDiscussionEntry(entry) {
   if (!entry || typeof entry !== "object") return entry;
@@ -9819,25 +10288,25 @@ function normalizeLegacyDiscussionEntry(entry) {
   return next;
 }
 function repoPoliciesDir(worktree) {
-  return path6.join(optimaDir(worktree), "policies");
+  return path8.join(optimaDir(worktree), "policies");
 }
 function generatedPoliciesDir(worktree) {
-  return path6.join(optimaLocalConfigDir(worktree), "generated", "policies");
+  return path8.join(optimaLocalConfigDir(worktree), "generated", "policies");
 }
 function generatedAgentsDir(worktree) {
-  return path6.join(optimaLocalConfigDir(worktree), "generated", "agents");
+  return path8.join(optimaLocalConfigDir(worktree), "generated", "agents");
 }
 function repoAgentsDir(worktree) {
-  return path6.join(optimaDir(worktree), "agents");
+  return path8.join(optimaDir(worktree), "agents");
 }
 function repoAgentAdditionsDir(worktree) {
-  return path6.join(optimaDir(worktree), "agent-additions");
+  return path8.join(optimaDir(worktree), "agent-additions");
 }
 function legacyRepoAgentsDir(worktree) {
-  return path6.join(legacyNomadworksDir(worktree), "agents");
+  return path8.join(legacyNomadworksDir(worktree), "agents");
 }
 function runtimeDiscussionRegistryPath(worktree) {
-  return path6.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
+  return path8.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
 }
 function resolveConfigPath(worktree) {
   return repoConfigPath(worktree);
@@ -9880,32 +10349,32 @@ function mergeClickUpAgentMetadata(existing, update = {}) {
   return JSON.stringify(sortJsonValue(merged), null, 2);
 }
 function optimaRuntimeDir(worktree) {
-  return path6.join(optimaLocalConfigDir(worktree), "runtime");
+  return path8.join(optimaLocalConfigDir(worktree), "runtime");
 }
 function clickUpWebhookStatePath(worktree) {
-  return path6.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
+  return path8.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
 }
 function clickUpCommentLedgerPath(worktree) {
-  return path6.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
+  return path8.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
 }
 function clickUpWebhookLogPath(worktree) {
-  return path6.join(optimaRuntimeDir(worktree), "clickup-webhook.log.jsonl");
+  return path8.join(optimaRuntimeDir(worktree), "clickup-webhook.log.jsonl");
 }
 function normalizeClickUpWebhookLogLevel(value) {
   const level = String(value || "info").trim().toLowerCase();
   return CLICKUP_WEBHOOK_LOG_LEVELS.has(level) ? level : "info";
 }
 function clickUpWebhookAuditLogDir() {
-  const dataHome = process.env.XDG_DATA_HOME && path6.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path6.join(os.homedir(), ".local", "share", "opencode");
-  return path6.join(dataHome, "opencode-optima");
+  const dataHome = process.env.XDG_DATA_HOME && path8.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path8.join(os2.homedir(), ".local", "share", "opencode");
+  return path8.join(dataHome, "opencode-optima");
 }
 function clickUpWebhookAuditLogPath(at = /* @__PURE__ */ new Date(), logDir = clickUpWebhookAuditLogDir()) {
-  return path6.join(logDir, `clickup-webhook-${at.toISOString().slice(0, 10)}.jsonl`);
+  return path8.join(logDir, `clickup-webhook-${at.toISOString().slice(0, 10)}.jsonl`);
 }
 function clickUpWebhookRequestFilePath(at = /* @__PURE__ */ new Date(), logDir = clickUpWebhookAuditLogDir()) {
   const stamp = at.toISOString().replace(/:/g, "-").replace(/\./g, "-");
-  const shortId = crypto.randomBytes(4).toString("hex");
-  return path6.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
+  const shortId = crypto2.randomBytes(4).toString("hex");
+  return path8.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
 }
 function findOptimaPluginTupleOptions(pluginEntries = []) {
   if (!Array.isArray(pluginEntries)) return null;
@@ -10065,7 +10534,7 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
   };
   const errors = [];
   if (!config.enabled) errors.push("clickup.enabled must be true");
-  if (!config.basePath || !path6.isAbsolute(config.basePath)) errors.push("clickup.base_path must be an absolute path");
+  if (!config.basePath || !path8.isAbsolute(config.basePath)) errors.push("clickup.base_path must be an absolute path");
   if (!config.teamId) errors.push("clickup.team_id is required");
   if (!config.apiToken) errors.push("clickup.api_token is required");
   if (!config.webhook.publicUrl) errors.push("clickup.webhook.public_url is required");
@@ -10128,21 +10597,21 @@ function sanitizeClickUpWebhookState(state = {}, config = null) {
 }
 function readClickUpWebhookState(worktree, config = null) {
   const statePath = clickUpWebhookStatePath(worktree);
-  if (!fs5.existsSync(statePath)) return sanitizeClickUpWebhookState({}, config);
+  if (!fs8.existsSync(statePath)) return sanitizeClickUpWebhookState({}, config);
   try {
-    return sanitizeClickUpWebhookState(JSON.parse(fs5.readFileSync(statePath, "utf8")), config);
+    return sanitizeClickUpWebhookState(JSON.parse(fs8.readFileSync(statePath, "utf8")), config);
   } catch {
     return sanitizeClickUpWebhookState({}, config);
   }
 }
 function writeClickUpWebhookState(worktree, state, config = null) {
   const statePath = clickUpWebhookStatePath(worktree);
-  fs5.mkdirSync(path6.dirname(statePath), { recursive: true, mode: 448 });
+  fs8.mkdirSync(path8.dirname(statePath), { recursive: true, mode: 448 });
   const next = sanitizeClickUpWebhookState(state, config);
-  fs5.writeFileSync(statePath, `${JSON.stringify(next, null, 2)}
+  fs8.writeFileSync(statePath, `${JSON.stringify(next, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs5.chmodSync(statePath, 384);
+    fs8.chmodSync(statePath, 384);
   } catch {
   }
   return next;
@@ -10155,26 +10624,6 @@ function isClickUpWebhookStateActive(state, config) {
     state?.active && state?.webhookId && state?.secret && state?.publicUrl === config?.webhook?.publicUrl && hasEvents
   );
 }
-function expandHomePath(value = "") {
-  const input = String(value || "").trim();
-  if (input === "~") return os.homedir();
-  if (input.startsWith("~/")) return path6.join(os.homedir(), input.slice(2));
-  return input;
-}
-function resolveSecretReference(value = "") {
-  const raw = String(value || "").trim();
-  const envMatch = raw.match(/^\{env:([A-Za-z_][A-Za-z0-9_]*)\}$/);
-  if (envMatch) return process.env[envMatch[1]] || "";
-  const fileMatch = raw.match(/^\{file:(.+)\}$/);
-  if (fileMatch) {
-    try {
-      return fs5.readFileSync(expandHomePath(fileMatch[1]), "utf8").trim();
-    } catch {
-      return "";
-    }
-  }
-  return raw;
-}
 function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
   const token = resolveSecretReference(config?.apiToken);
   const request = async (url, options = {}) => {
@@ -10239,212 +10688,6 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
     }
   };
 }
-function base64UrlJson(value) {
-  return Buffer.from(JSON.stringify(value)).toString("base64url");
-}
-function resolveGitHubAppPrivateKey(app = {}) {
-  const direct = resolveSecretReference(app.privateKey || "");
-  if (direct) return direct.replace(/\\n/g, "\n");
-  const file = expandHomePath(app.privateKeyFile || "");
-  if (!file) return "";
-  try {
-    return fs5.readFileSync(file, "utf8").trim().replace(/\\n/g, "\n");
-  } catch {
-    return "";
-  }
-}
-function createGitHubAppJwt({ appId, privateKey, now = () => /* @__PURE__ */ new Date() } = {}) {
-  const key = String(privateKey || "").trim();
-  const issuer = String(appId || "").trim();
-  if (!issuer || !key) throw new Error("GitHub App app_id and private key are required");
-  const nowSeconds = Math.floor(now().getTime() / 1e3);
-  const header = base64UrlJson({ alg: "RS256", typ: "JWT" });
-  const payload = base64UrlJson({ iat: nowSeconds - 60, exp: nowSeconds + 540, iss: issuer });
-  const unsigned = `${header}.${payload}`;
-  const signature = crypto.createSign("RSA-SHA256").update(unsigned).end().sign(key, "base64url");
-  return `${unsigned}.${signature}`;
-}
-function encodeGitHubPathSegment(value) {
-  return encodeURIComponent(String(value || ""));
-}
-function encodeGitHubBranchRef(branch = "") {
-  return String(branch || "").split("/").map(encodeGitHubPathSegment).join("/");
-}
-function parseNullSeparatedGitOutput(output = "") {
-  return String(output || "").split("\0").map((item) => item.trim()).filter(Boolean);
-}
-function listWorktreeChangedPaths(worktree, runGitFn = runGit) {
-  const tracked = parseNullSeparatedGitOutput(runGitFn(worktree, ["diff", "--name-only", "-z", "HEAD", "--"]));
-  const untracked = parseNullSeparatedGitOutput(runGitFn(worktree, ["ls-files", "--others", "--exclude-standard", "-z", "--"]));
-  return [.../* @__PURE__ */ new Set([...tracked, ...untracked])].filter((item) => item && !item.startsWith("../") && !path6.isAbsolute(item));
-}
-function currentGitBranch(worktree, runGitFn = runGit) {
-  return String(runGitFn(worktree, ["rev-parse", "--abbrev-ref", "HEAD"]) || "").trim();
-}
-function treeEntryForWorktreePath(worktree, gitPath) {
-  const absolutePath = path6.join(worktree, ...String(gitPath || "").split("/"));
-  if (!fs5.existsSync(absolutePath)) return { path: gitPath, mode: "100644", type: "blob", sha: null, deleted: true };
-  const stat = fs5.lstatSync(absolutePath);
-  if (stat.isDirectory()) return null;
-  if (stat.isSymbolicLink()) {
-    return {
-      path: gitPath,
-      mode: "120000",
-      type: "blob",
-      content: fs5.readlinkSync(absolutePath),
-      encoding: "utf-8"
-    };
-  }
-  return {
-    path: gitPath,
-    mode: stat.mode & 73 ? "100755" : "100644",
-    type: "blob",
-    content: fs5.readFileSync(absolutePath).toString("base64"),
-    encoding: "base64"
-  };
-}
-function createGitHubApiClient(config = {}, fetchImpl = globalThis.fetch) {
-  const staticToken = resolveSecretReference(config?.apiToken);
-  const appConfig = isPlainObject(config?.app) ? config.app : {};
-  const appEnabled = appConfig.enabled === true || Boolean(appConfig.appId && appConfig.installationId && (appConfig.privateKey || appConfig.privateKeyFile));
-  const privateKey = resolveGitHubAppPrivateKey(appConfig);
-  const owner = String(config?.owner || "").trim();
-  const repo = String(config?.repo || "").trim();
-  let installationToken = null;
-  let installationTokenExpiresAt = 0;
-  const requestJson = async (url, { method = "GET", headers = {}, body = void 0 } = {}) => {
-    if (typeof fetchImpl !== "function") throw new Error("fetch is unavailable; inject a GitHub client for live PR lookup");
-    const response = await fetchImpl(url, {
-      method,
-      headers: {
-        Accept: "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-        ...body === void 0 ? {} : { "Content-Type": "application/json" },
-        ...headers
-      },
-      ...body === void 0 ? {} : { body: JSON.stringify(body) }
-    });
-    if (!response.ok) throw new Error(`GitHub API request failed: ${response.status}`);
-    return response.status === 204 ? null : response.json();
-  };
-  const getAuthToken = async () => {
-    if (!appEnabled) return staticToken || "";
-    const nowMs = Date.now();
-    if (installationToken && installationTokenExpiresAt - 6e4 > nowMs) return installationToken;
-    const jwt = createGitHubAppJwt({ appId: appConfig.appId, privateKey });
-    const installation = await requestJson(`https://api.github.com/app/installations/${encodeURIComponent(appConfig.installationId)}/access_tokens`, {
-      method: "POST",
-      headers: { Authorization: `Bearer ${jwt}` }
-    });
-    installationToken = String(installation?.token || "").trim();
-    installationTokenExpiresAt = Date.parse(installation?.expires_at || "") || nowMs + 3e6;
-    if (!installationToken) throw new Error("GitHub App installation token response did not include a token");
-    return installationToken;
-  };
-  const request = async (pathname, { method = "GET", body = void 0 } = {}) => {
-    if (!owner || !repo) throw new Error("GitHub repository owner/repo is not configured");
-    const token = await getAuthToken();
-    return requestJson(`https://api.github.com/repos/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}${pathname}`, {
-      method,
-      body,
-      headers: token ? { Authorization: `Bearer ${token}` } : {}
-    });
-  };
-  const getRef = async (branch) => request(`/git/ref/heads/${encodeGitHubBranchRef(branch)}`);
-  const getCommitObject = async (sha) => request(`/git/commits/${encodeURIComponent(sha)}`);
-  const createBlob = async ({ content, encoding }) => request("/git/blobs", { method: "POST", body: { content, encoding } });
-  const createTree = async ({ baseTree, tree }) => request("/git/trees", { method: "POST", body: { base_tree: baseTree, tree } });
-  const createCommit = async ({ message, treeSha, parents }) => request("/git/commits", { method: "POST", body: { message, tree: treeSha, parents } });
-  const updateRef = async ({ branch, sha, force = false }) => request(`/git/refs/heads/${encodeGitHubBranchRef(branch)}`, { method: "PATCH", body: { sha, force } });
-  return {
-    async getPullRequest(number) {
-      return request(`/pulls/${encodeURIComponent(number)}`);
-    },
-    async createPullRequest({ title, head, base, body = "", draft = false, maintainerCanModify = true }) {
-      return request("/pulls", {
-        method: "POST",
-        body: {
-          title: String(title || ""),
-          head: String(head || ""),
-          base: String(base || ""),
-          body: String(body || ""),
-          draft: draft === true,
-          maintainer_can_modify: maintainerCanModify !== false
-        }
-      });
-    },
-    async createIssueComment({ issueNumber, body }) {
-      return request(`/issues/${encodeURIComponent(issueNumber)}/comments`, { method: "POST", body: { body: String(body || "") } });
-    },
-    async replyToReviewComment({ commentId, body }) {
-      return request(`/pulls/comments/${encodeURIComponent(commentId)}/replies`, { method: "POST", body: { body: String(body || "") } });
-    },
-    async createPullRequestReview({ pullNumber, body, event = "COMMENT" }) {
-      return request(`/pulls/${encodeURIComponent(pullNumber)}/reviews`, { method: "POST", body: { body: String(body || ""), event: String(event || "COMMENT").toUpperCase() } });
-    },
-    async mergePullRequest({ pullNumber, commitTitle = "", commitMessage = "", mergeMethod = "squash" }) {
-      const body = {
-        merge_method: String(mergeMethod || "squash")
-      };
-      if (commitTitle) body.commit_title = String(commitTitle);
-      if (commitMessage) body.commit_message = String(commitMessage);
-      return request(`/pulls/${encodeURIComponent(pullNumber)}/merge`, { method: "PUT", body });
-    },
-    async commitWorktree({ worktree, branch = "", message = "", runGitFn = runGit, syncLocal = false } = {}) {
-      const directory = path6.resolve(String(worktree || ""));
-      if (!directory || !fs5.existsSync(directory)) throw new Error("worktree does not exist");
-      const targetBranch = String(branch || currentGitBranch(directory, runGitFn)).trim();
-      if (!targetBranch || targetBranch === "HEAD") throw new Error("target branch is required for GitHub API commit");
-      const commitMessage = String(message || "").trim();
-      if (!commitMessage) throw new Error("commit message is required");
-      const changedPaths = listWorktreeChangedPaths(directory, runGitFn);
-      if (changedPaths.length === 0) return { ok: true, action: "no_changes", branch: targetBranch, changedPaths: [] };
-      const ref = await getRef(targetBranch);
-      const headSha = ref?.object?.sha;
-      if (!headSha) throw new Error(`GitHub ref for ${targetBranch} did not include a head sha`);
-      const headCommit = await getCommitObject(headSha);
-      const baseTree = headCommit?.tree?.sha;
-      if (!baseTree) throw new Error(`GitHub commit ${headSha} did not include a tree sha`);
-      const tree = [];
-      for (const gitPath of changedPaths) {
-        const entry = treeEntryForWorktreePath(directory, gitPath);
-        if (!entry) continue;
-        if (entry.deleted) {
-          tree.push({ path: entry.path, mode: entry.mode, type: entry.type, sha: null });
-          continue;
-        }
-        const blob = await createBlob({ content: entry.content, encoding: entry.encoding });
-        if (!blob?.sha) throw new Error(`GitHub blob creation failed for ${gitPath}`);
-        tree.push({ path: entry.path, mode: entry.mode, type: entry.type, sha: blob.sha });
-      }
-      if (tree.length === 0) return { ok: true, action: "no_changes", branch: targetBranch, changedPaths: [] };
-      const nextTree = await createTree({ baseTree, tree });
-      const nextCommit = await createCommit({ message: commitMessage, treeSha: nextTree.sha, parents: [headSha] });
-      if (!nextCommit?.sha) throw new Error("GitHub commit creation did not return a sha");
-      const updatedRef = await updateRef({ branch: targetBranch, sha: nextCommit.sha, force: false });
-      if (syncLocal) {
-        runGitFn(directory, ["fetch", "origin", targetBranch]);
-        runGitFn(directory, ["reset", "--hard", "FETCH_HEAD"]);
-      }
-      return {
-        ok: true,
-        action: "committed",
-        branch: targetBranch,
-        before: headSha,
-        after: nextCommit.sha,
-        changedPaths,
-        treeEntries: tree.length,
-        verification: nextCommit.verification || null,
-        ref: updatedRef
-      };
-    },
-    async authMode() {
-      if (appEnabled) return { mode: "github_app", appId: String(appConfig.appId || ""), installationId: String(appConfig.installationId || "") };
-      if (staticToken) return { mode: "token" };
-      return { mode: "anonymous" };
-    }
-  };
-}
 function createTestClickUpApiClient(config) {
   const metadata = /* @__PURE__ */ new Map();
   return {
@@ -10670,10 +10913,10 @@ async function ensureClickUpWebhookSubscription({ validation, worktree, clickupC
 function verifyClickUpSignature(rawBody, signatureHeader, secret) {
   const signature = String(signatureHeader || "").replace(/^sha256=/i, "").trim();
   if (!signature || !secret) return false;
-  const expected = crypto.createHmac("sha256", secret).update(Buffer.isBuffer(rawBody) ? rawBody : String(rawBody || ""), "utf8").digest("hex");
+  const expected = crypto2.createHmac("sha256", secret).update(Buffer.isBuffer(rawBody) ? rawBody : String(rawBody || ""), "utf8").digest("hex");
   const given = Buffer.from(signature, "hex");
   const wanted = Buffer.from(expected, "hex");
-  return given.length === wanted.length && crypto.timingSafeEqual(given, wanted);
+  return given.length === wanted.length && crypto2.timingSafeEqual(given, wanted);
 }
 function verifyGitHubSignature(rawBody, signatureHeader, secret) {
   return verifyClickUpSignature(rawBody, signatureHeader, secret);
@@ -10727,9 +10970,9 @@ function rememberClickUpWebhookEvent(state = {}, eventKey, limit = 200) {
   return { duplicate: false, state: { ...state, recentEventKeys: [...recent, eventKey].slice(-limit) } };
 }
 function readClickUpCommentLedgerEntries(ledgerPath) {
-  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return [];
+  if (!ledgerPath || !fs8.existsSync(ledgerPath)) return [];
   try {
-    const raw = fs5.readFileSync(ledgerPath, "utf8");
+    const raw = fs8.readFileSync(ledgerPath, "utf8");
     const entries = [];
     for (const [index, line] of raw.split(/\r?\n/).entries()) {
       if (!line.trim()) continue;
@@ -10753,11 +10996,11 @@ function readClickUpCommentLedger(ledgerPath) {
 }
 function appendClickUpCommentLedgerEntry(ledgerPath, entry = {}) {
   if (!ledgerPath || !entry.key) return;
-  fs5.mkdirSync(path6.dirname(ledgerPath), { recursive: true, mode: 448 });
-  fs5.appendFileSync(ledgerPath, `${JSON.stringify(entry)}
+  fs8.mkdirSync(path8.dirname(ledgerPath), { recursive: true, mode: 448 });
+  fs8.appendFileSync(ledgerPath, `${JSON.stringify(entry)}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs5.chmodSync(ledgerPath, 384);
+    fs8.chmodSync(ledgerPath, 384);
   } catch {
   }
 }
@@ -10776,7 +11019,7 @@ function stableClickUpCommentVersionMarker(value) {
   const direct = value.version ?? value.date_updated ?? value.updated_at ?? value.revision ?? value.modified_at;
   const directMarker = stableClickUpCommentVersionMarker(direct);
   if (directMarker) return directMarker;
-  return `json:${crypto.createHash("sha256").update(JSON.stringify(value, Object.keys(value).sort())).digest("hex").slice(0, 16)}`;
+  return `json:${crypto2.createHash("sha256").update(JSON.stringify(value, Object.keys(value).sort())).digest("hex").slice(0, 16)}`;
 }
 function clickUpCommentLedgerKey({ taskId, eventType, payload }) {
   const history = Array.isArray(payload?.history_items) ? payload.history_items[0] : payload?.history_item;
@@ -10786,7 +11029,7 @@ function clickUpCommentLedgerKey({ taskId, eventType, payload }) {
   const explicitVersion = stableClickUpCommentVersionMarker(
     comment?.date_updated || comment?.dateUpdated || comment?.updated_at || comment?.updatedAt || comment?._version_vector || comment?.version_vector || comment?.versionVector || comment?.version || comment?.revision || comment?.modified_at || comment?.modifiedAt || ""
   );
-  const contentVersion = crypto.createHash("sha256").update(JSON.stringify({ text: clickUpCommentText(comment), parts: Array.isArray(comment.comment) ? comment.comment : null })).digest("hex").slice(0, 16);
+  const contentVersion = crypto2.createHash("sha256").update(JSON.stringify({ text: clickUpCommentText(comment), parts: Array.isArray(comment.comment) ? comment.comment : null })).digest("hex").slice(0, 16);
   return [String(taskId || "").trim(), "comment", commentId, explicitVersion || `sha256-${contentVersion}`].filter(Boolean).join(":");
 }
 function isClickUpCommentVersionProcessed({ ledgerPath, key, ledger = null, worktree = process.cwd() } = {}) {
@@ -11316,7 +11559,7 @@ function clampOpenCodeSessionText(text = "", maxLength = 12e3) {
   return value.length > maxLength ? value.slice(0, maxLength) : value;
 }
 function hashOpenCodeSessionText(text = "") {
-  return crypto.createHash("sha256").update(String(text ?? "")).digest("hex");
+  return crypto2.createHash("sha256").update(String(text ?? "")).digest("hex");
 }
 async function readOpenCodeSessionMessages(client, { sessionId, directory, limit = 20 } = {}) {
   if (typeof client?.session?.messages !== "function") return null;
@@ -11554,7 +11797,7 @@ async function readOpenCodeSessionControl(client, { sessionId, directory, limit
   };
 }
 async function probeOpenCodeSessionControl(client, { directory, agent, omitAgentOnPrompt = false, text = "" } = {}) {
-  const requestedMarker = text || `optima-session-probe-${crypto.randomUUID()}`;
+  const requestedMarker = text || `optima-session-probe-${crypto2.randomUUID()}`;
   const marker = clampOpenCodeSessionText(requestedMarker);
   const create = await createOpenCodeSessionControl(client, {
     directory,
@@ -11782,9 +12025,9 @@ function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", w
 }
 function appendClickUpWebhookLocalLog(worktree, entry) {
   const logPath = clickUpWebhookLogPath(worktree);
-  fs5.mkdirSync(path6.dirname(logPath), { recursive: true });
+  fs8.mkdirSync(path8.dirname(logPath), { recursive: true });
   const safeEntry = { ...entry, at: entry.at || (/* @__PURE__ */ new Date()).toISOString() };
-  fs5.appendFileSync(logPath, `${JSON.stringify(safeEntry)}
+  fs8.appendFileSync(logPath, `${JSON.stringify(safeEntry)}
 `, "utf8");
 }
 function clickUpWebhookLifecycleLog(worktree, entry) {
@@ -11813,7 +12056,7 @@ function closeClickUpWebhookServer(server) {
   });
 }
 function managedClickUpWebhookKey({ worktree, state, config } = {}) {
-  return [path6.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
+  return [path8.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
 }
 async function deleteClickUpWebhookBestEffort({ webhookId, clickupClient, worktree, reason = "cleanup" } = {}) {
   const id = String(webhookId || "").trim();
@@ -11913,7 +12156,7 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
     const failed = Boolean(error || !handled?.ok || (handled?.status || 500) >= 400);
     if (level === "error" && !failed) return;
     const logDir = clickUpWebhookAuditLogDir();
-    fs5.mkdirSync(logDir, { recursive: true });
+    fs8.mkdirSync(logDir, { recursive: true });
     const secretValues = [
       resolveSecretReference(config?.apiToken),
       resolveSecretReference(config?.github?.apiToken),
@@ -11924,8 +12167,8 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
     let requestFile;
     if (level === "verbose") {
       const absoluteRequestFile = clickUpWebhookRequestFilePath(at, logDir);
-      fs5.mkdirSync(path6.dirname(absoluteRequestFile), { recursive: true });
-      requestFile = path6.relative(logDir, absoluteRequestFile).split(path6.sep).join("/");
+      fs8.mkdirSync(path8.dirname(absoluteRequestFile), { recursive: true });
+      requestFile = path8.relative(logDir, absoluteRequestFile).split(path8.sep).join("/");
       const parsedBody = payload || (() => {
         try {
           return JSON.parse(Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody || ""));
@@ -11941,11 +12184,11 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
         headers,
         body: parsedBody === void 0 ? Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody || "") : parsedBody
       }, secretValues);
-      fs5.writeFileSync(absoluteRequestFile, `${JSON.stringify(requestArtifact, null, 2)}
+      fs8.writeFileSync(absoluteRequestFile, `${JSON.stringify(requestArtifact, null, 2)}
 `, "utf8");
     }
     const summary = redactClickUpWebhookAuditValue(buildClickUpWebhookAuditSummary({ method, url, config, handled, error, payload, requestFile, at }), secretValues);
-    fs5.appendFileSync(clickUpWebhookAuditLogPath(at, logDir), `${JSON.stringify(summary)}
+    fs8.appendFileSync(clickUpWebhookAuditLogPath(at, logDir), `${JSON.stringify(summary)}
 `, "utf8");
   } catch {
   }
@@ -11963,7 +12206,7 @@ async function withClickUpTaskRouteLock(taskId, operation) {
     if (activeClickUpTaskRoutes.get(key) === current) activeClickUpTaskRoutes.delete(key);
   }
 }
-async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktreeForWebhook, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
+async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktreeForWebhook, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os2.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
   const eventType = clickUpEventType(payload);
   const eventKey = clickUpWebhookEventKey(payload);
   const isStartupAssignmentReconciliation = payload?.startup_reconciliation === true && eventType === "taskAssigneeUpdated";
@@ -12732,17 +12975,17 @@ function startClickUpWebhookListener({ config, state, worktree, clickupClient, g
   return result;
 }
 function legacyVariantPath(destinationPath) {
-  const parsed = path6.parse(destinationPath);
+  const parsed = path8.parse(destinationPath);
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-  if (parsed.ext) return path6.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
-  return path6.join(parsed.dir, `${parsed.base}.legacy-${stamp}`);
+  if (parsed.ext) return path8.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
+  return path8.join(parsed.dir, `${parsed.base}.legacy-${stamp}`);
 }
 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 (path6.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
+  if (path8.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
   if (normalized === "tasks" || normalized.startsWith("tasks/")) {
     return {
       ok: false,
@@ -12760,78 +13003,78 @@ function normalizeWorkflowTaskPath(taskPath) {
 function mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, gitState = null) {
   const sourceWasTracked = isGitTracked(gitState, sourcePath);
   if (gitAwareMoveIfTracked(sourcePath, destinationPath, gitState)) return;
-  if (!fs5.existsSync(destinationPath)) {
-    fs5.mkdirSync(path6.dirname(destinationPath), { recursive: true });
-    fs5.renameSync(sourcePath, destinationPath);
+  if (!fs8.existsSync(destinationPath)) {
+    fs8.mkdirSync(path8.dirname(destinationPath), { recursive: true });
+    fs8.renameSync(sourcePath, destinationPath);
     if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
-  const ext = path6.extname(destinationPath).toLowerCase();
+  const ext = path8.extname(destinationPath).toLowerCase();
   if ([".yaml", ".yml", ".json"].includes(ext)) {
-    const sourceRaw = fs5.readFileSync(sourcePath, "utf8");
-    const destRaw = fs5.readFileSync(destinationPath, "utf8");
+    const sourceRaw = fs8.readFileSync(sourcePath, "utf8");
+    const destRaw = fs8.readFileSync(destinationPath, "utf8");
     const parser = ext === ".json" ? JSON : import_yaml3.default;
     const sourceValue = parser.parse(sourceRaw) || {};
     const destValue = parser.parse(destRaw) || {};
     const merged = mergeStructuredValues(sourceValue, destValue);
     const serialized = ext === ".json" ? `${JSON.stringify(merged, null, 2)}
 ` : import_yaml3.default.stringify(merged);
-    fs5.writeFileSync(destinationPath, serialized, "utf8");
-    fs5.unlinkSync(sourcePath);
+    fs8.writeFileSync(destinationPath, serialized, "utf8");
+    fs8.unlinkSync(sourcePath);
     stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
   if (ext === ".md") {
-    const sourceRaw = fs5.readFileSync(sourcePath, "utf8").trimEnd();
-    const destRaw = fs5.readFileSync(destinationPath, "utf8").trimEnd();
+    const sourceRaw = fs8.readFileSync(sourcePath, "utf8").trimEnd();
+    const destRaw = fs8.readFileSync(destinationPath, "utf8").trimEnd();
     if (sourceRaw && !destRaw.includes(sourceRaw)) {
       const marker = `## Legacy Content From ${relativeSource}`;
-      fs5.writeFileSync(destinationPath, `${destRaw}
+      fs8.writeFileSync(destinationPath, `${destRaw}
 
 ${marker}
 
 ${sourceRaw}
 `, "utf8");
     }
-    fs5.unlinkSync(sourcePath);
+    fs8.unlinkSync(sourcePath);
     stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
   const preservedPath = legacyVariantPath(destinationPath);
-  fs5.renameSync(sourcePath, preservedPath);
+  fs8.renameSync(sourcePath, preservedPath);
   stageGitAwareMerge(sourcePath, preservedPath, gitState);
 }
-function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path6.basename(sourcePath), gitState = null) {
-  if (!fs5.existsSync(sourcePath)) return;
-  const stat = fs5.statSync(sourcePath);
+function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path8.basename(sourcePath), gitState = null) {
+  if (!fs8.existsSync(sourcePath)) return;
+  const stat = fs8.statSync(sourcePath);
   if (stat.isDirectory()) {
     const sourceWasTracked = isGitTracked(gitState, sourcePath) || hasGitTrackedChildren(gitState, sourcePath);
     if (gitAwareMoveIfTracked(sourcePath, destinationPath, gitState)) return;
-    if (!fs5.existsSync(destinationPath)) {
-      fs5.mkdirSync(path6.dirname(destinationPath), { recursive: true });
-      fs5.renameSync(sourcePath, destinationPath);
+    if (!fs8.existsSync(destinationPath)) {
+      fs8.mkdirSync(path8.dirname(destinationPath), { recursive: true });
+      fs8.renameSync(sourcePath, destinationPath);
       if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
       return;
     }
-    fs5.mkdirSync(destinationPath, { recursive: true });
-    for (const entry of fs5.readdirSync(sourcePath)) {
+    fs8.mkdirSync(destinationPath, { recursive: true });
+    for (const entry of fs8.readdirSync(sourcePath)) {
       mergePathIntoDestination(
-        path6.join(sourcePath, entry),
-        path6.join(destinationPath, entry),
-        path6.join(relativeSource, entry),
+        path8.join(sourcePath, entry),
+        path8.join(destinationPath, entry),
+        path8.join(relativeSource, entry),
         gitState
       );
     }
-    fs5.rmSync(sourcePath, { recursive: true, force: true });
+    fs8.rmSync(sourcePath, { recursive: true, force: true });
     return;
   }
   mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, gitState);
 }
 function isOptimaPluginPackageWorktree(worktree) {
-  const packageJsonPath = path6.join(worktree, "package.json");
-  if (!fs5.existsSync(packageJsonPath)) return false;
+  const packageJsonPath = path8.join(worktree, "package.json");
+  if (!fs8.existsSync(packageJsonPath)) return false;
   try {
-    const pkg = JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(fs8.readFileSync(packageJsonPath, "utf8"));
     return pkg?.name === "@defend-tech/opencode-optima";
   } catch {
     return false;
@@ -12840,59 +13083,59 @@ function isOptimaPluginPackageWorktree(worktree) {
 function migrateLegacyOptimaLayout(worktree) {
   const gitState = gitMigrationState(worktree);
   const migrations = [
-    [path6.join(legacyOrbitaDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".orbita", "orbita.yaml")],
-    [path6.join(legacyOrbitaDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".orbita", "staticeng.yaml")],
-    [path6.join(legacyOrbitaDir(worktree), ".config"), optimaLocalConfigDir(worktree), path6.join(".orbita", ".config")],
-    [path6.join(legacyOrbitaDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".orbita", "config")],
-    [path6.join(legacyOrbitaDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".orbita", "runtime")],
-    [path6.join(legacyOrbitaDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".orbita", "generated")],
+    [path8.join(legacyOrbitaDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path8.join(".orbita", "orbita.yaml")],
+    [path8.join(legacyOrbitaDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path8.join(".orbita", "staticeng.yaml")],
+    [path8.join(legacyOrbitaDir(worktree), ".config"), optimaLocalConfigDir(worktree), path8.join(".orbita", ".config")],
+    [path8.join(legacyOrbitaDir(worktree), "config"), optimaLocalConfigDir(worktree), path8.join(".orbita", "config")],
+    [path8.join(legacyOrbitaDir(worktree), "runtime"), path8.join(optimaLocalConfigDir(worktree), "runtime"), path8.join(".orbita", "runtime")],
+    [path8.join(legacyOrbitaDir(worktree), "generated"), path8.join(optimaLocalConfigDir(worktree), "generated"), path8.join(".orbita", "generated")],
     [legacyOrbitaDir(worktree), optimaDir(worktree), ".orbita"],
-    [path6.join(legacyStaticEngDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".staticeng", "staticeng.yaml")],
-    [path6.join(legacyStaticEngDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".staticeng", "orbita.yaml")],
-    [path6.join(legacyStaticEngDir(worktree), ".config"), optimaLocalConfigDir(worktree), path6.join(".staticeng", ".config")],
-    [path6.join(legacyStaticEngDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".staticeng", "config")],
-    [path6.join(legacyStaticEngDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".staticeng", "runtime")],
-    [path6.join(legacyStaticEngDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".staticeng", "generated")],
+    [path8.join(legacyStaticEngDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path8.join(".staticeng", "staticeng.yaml")],
+    [path8.join(legacyStaticEngDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path8.join(".staticeng", "orbita.yaml")],
+    [path8.join(legacyStaticEngDir(worktree), ".config"), optimaLocalConfigDir(worktree), path8.join(".staticeng", ".config")],
+    [path8.join(legacyStaticEngDir(worktree), "config"), optimaLocalConfigDir(worktree), path8.join(".staticeng", "config")],
+    [path8.join(legacyStaticEngDir(worktree), "runtime"), path8.join(optimaLocalConfigDir(worktree), "runtime"), path8.join(".staticeng", "runtime")],
+    [path8.join(legacyStaticEngDir(worktree), "generated"), path8.join(optimaLocalConfigDir(worktree), "generated"), path8.join(".staticeng", "generated")],
     [legacyStaticEngDir(worktree), optimaDir(worktree), ".staticeng"],
-    [path6.join(legacyNomadworkDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "nomadworks.yaml")],
-    [path6.join(legacyNomadworksDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "nomadworks.yaml")],
-    [path6.join(legacyNomadworkDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "staticeng.yaml")],
-    [path6.join(legacyNomadworksDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "staticeng.yaml")],
-    [path6.join(legacyNomadworkDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "orbita.yaml")],
-    [path6.join(legacyNomadworksDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "orbita.yaml")],
-    [path6.join(legacyNomadworkDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".nomadwork", "runtime")],
-    [path6.join(legacyNomadworksDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".nomadworks", "runtime")],
-    [path6.join(legacyNomadworkDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".nomadwork", "generated")],
-    [path6.join(legacyNomadworksDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".nomadworks", "generated")],
-    [path6.join(legacyNomadworkDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".nomadwork", "config")],
-    [path6.join(legacyNomadworksDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".nomadworks", "config")],
+    [path8.join(legacyNomadworkDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path8.join(".nomadwork", "nomadworks.yaml")],
+    [path8.join(legacyNomadworksDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path8.join(".nomadworks", "nomadworks.yaml")],
+    [path8.join(legacyNomadworkDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path8.join(".nomadwork", "staticeng.yaml")],
+    [path8.join(legacyNomadworksDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path8.join(".nomadworks", "staticeng.yaml")],
+    [path8.join(legacyNomadworkDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path8.join(".nomadwork", "orbita.yaml")],
+    [path8.join(legacyNomadworksDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path8.join(".nomadworks", "orbita.yaml")],
+    [path8.join(legacyNomadworkDir(worktree), "runtime"), path8.join(optimaLocalConfigDir(worktree), "runtime"), path8.join(".nomadwork", "runtime")],
+    [path8.join(legacyNomadworksDir(worktree), "runtime"), path8.join(optimaLocalConfigDir(worktree), "runtime"), path8.join(".nomadworks", "runtime")],
+    [path8.join(legacyNomadworkDir(worktree), "generated"), path8.join(optimaLocalConfigDir(worktree), "generated"), path8.join(".nomadwork", "generated")],
+    [path8.join(legacyNomadworksDir(worktree), "generated"), path8.join(optimaLocalConfigDir(worktree), "generated"), path8.join(".nomadworks", "generated")],
+    [path8.join(legacyNomadworkDir(worktree), "config"), optimaLocalConfigDir(worktree), path8.join(".nomadwork", "config")],
+    [path8.join(legacyNomadworksDir(worktree), "config"), optimaLocalConfigDir(worktree), path8.join(".nomadworks", "config")],
     [legacyNomadworkDir(worktree), optimaDir(worktree), ".nomadwork"],
     [legacyNomadworksDir(worktree), optimaDir(worktree), ".nomadworks"],
-    [path6.join(worktree, "tasks"), optimaTasksDir(worktree), "tasks"],
-    [path6.join(worktree, "evidences"), optimaEvidencesDir(worktree), "evidences"],
-    [path6.join(worktree, "docs", "scrs"), optimaScrsDir(worktree), path6.join("docs", "scrs")],
-    [path6.join(worktree, "codemap.yml"), optimaCodemapPath(worktree), "codemap.yml"],
-    [path6.join(worktree, "codemap.yaml"), optimaCodemapPath(worktree), "codemap.yaml"]
+    [path8.join(worktree, "tasks"), optimaTasksDir(worktree), "tasks"],
+    [path8.join(worktree, "evidences"), optimaEvidencesDir(worktree), "evidences"],
+    [path8.join(worktree, "docs", "scrs"), optimaScrsDir(worktree), path8.join("docs", "scrs")],
+    [path8.join(worktree, "codemap.yml"), optimaCodemapPath(worktree), "codemap.yml"],
+    [path8.join(worktree, "codemap.yaml"), optimaCodemapPath(worktree), "codemap.yaml"]
   ];
   if (!isOptimaPluginPackageWorktree(worktree)) {
-    migrations.push([path6.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
+    migrations.push([path8.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
   }
   for (const [source, destination, relativeSource] of migrations) {
-    if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
+    if (fs8.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
   for (const [source, destination, relativeSource] of [
-    [path6.join(optimaDir(worktree), "optima.yaml"), repoConfigPath(worktree), path6.join(".optima", "optima.yaml")],
-    [path6.join(optimaDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".optima", "config")],
-    [path6.join(optimaDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".optima", "runtime")],
-    [path6.join(optimaDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".optima", "generated")]
+    [path8.join(optimaDir(worktree), "optima.yaml"), repoConfigPath(worktree), path8.join(".optima", "optima.yaml")],
+    [path8.join(optimaDir(worktree), "config"), optimaLocalConfigDir(worktree), path8.join(".optima", "config")],
+    [path8.join(optimaDir(worktree), "runtime"), path8.join(optimaLocalConfigDir(worktree), "runtime"), path8.join(".optima", "runtime")],
+    [path8.join(optimaDir(worktree), "generated"), path8.join(optimaLocalConfigDir(worktree), "generated"), path8.join(".optima", "generated")]
   ]) {
-    if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
+    if (fs8.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
 }
 function listMarkdownFiles(dirPath) {
-  if (!fs5.existsSync(dirPath)) return [];
+  if (!fs8.existsSync(dirPath)) return [];
   try {
-    return fs5.readdirSync(dirPath).filter((file) => file.endsWith(".md") && file.toLowerCase() !== "readme.md");
+    return fs8.readdirSync(dirPath).filter((file) => file.endsWith(".md") && file.toLowerCase() !== "readme.md");
   } catch (e) {
     console.error(`[Optima] Failed to read markdown files from ${dirPath}:`, e);
     return [];
@@ -12933,10 +13176,10 @@ function toModelString(provider, model) {
 }
 function readTaskMetadata(taskPath, worktree) {
   if (!taskPath) return {};
-  const absoluteTaskPath = path6.isAbsolute(taskPath) ? taskPath : path6.join(worktree, taskPath);
-  if (!fs5.existsSync(absoluteTaskPath)) return {};
+  const absoluteTaskPath = path8.isAbsolute(taskPath) ? taskPath : path8.join(worktree, taskPath);
+  if (!fs8.existsSync(absoluteTaskPath)) return {};
   try {
-    const raw = fs5.readFileSync(absoluteTaskPath, "utf8");
+    const raw = fs8.readFileSync(absoluteTaskPath, "utf8");
     const { data } = parseFrontmatter(raw);
     return {
       complexity: typeof data.complexity === "string" ? data.complexity.trim().toLowerCase() : void 0,
@@ -12961,11 +13204,11 @@ function slugifyTitle(input) {
 }
 function loadDiscussionRegistry(worktree) {
   const registryPath = runtimeDiscussionRegistryPath(worktree);
-  if (!fs5.existsSync(registryPath)) {
+  if (!fs8.existsSync(registryPath)) {
     return { version: 1, active: {} };
   }
   try {
-    const parsed = JSON.parse(fs5.readFileSync(registryPath, "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(registryPath, "utf8"));
     const registry = {
       version: 1,
       active: Object.fromEntries(Object.entries(parsed.active || {}).map(([key, value]) => [key, normalizeLegacyDiscussionEntry(value)]))
@@ -12978,34 +13221,34 @@ function loadDiscussionRegistry(worktree) {
 }
 function saveDiscussionRegistry(worktree, registry) {
   const registryPath = runtimeDiscussionRegistryPath(worktree);
-  const runtimeDir = path6.dirname(registryPath);
-  if (!fs5.existsSync(runtimeDir)) fs5.mkdirSync(runtimeDir, { recursive: true });
-  fs5.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
+  const runtimeDir = path8.dirname(registryPath);
+  if (!fs8.existsSync(runtimeDir)) fs8.mkdirSync(runtimeDir, { recursive: true });
+  fs8.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
 }
 function runtimeDiscussionsDir(worktree) {
-  return path6.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
+  return path8.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
 }
 function archivedRuntimeDiscussionsDir(worktree) {
-  return path6.join(runtimeDiscussionsDir(worktree), "archive");
+  return path8.join(runtimeDiscussionsDir(worktree), "archive");
 }
 function finalDiscussionsDir(worktree) {
-  return path6.join(optimaTasksDir(worktree), "discussions");
+  return path8.join(optimaTasksDir(worktree), "discussions");
 }
 function nextDiscussionIdentity(worktree, title) {
   const discussionsDir = finalDiscussionsDir(worktree);
   const runtimeDir = runtimeDiscussionsDir(worktree);
-  if (!fs5.existsSync(discussionsDir)) fs5.mkdirSync(discussionsDir, { recursive: true });
-  if (!fs5.existsSync(runtimeDir)) fs5.mkdirSync(runtimeDir, { recursive: true });
+  if (!fs8.existsSync(discussionsDir)) fs8.mkdirSync(discussionsDir, { recursive: true });
+  if (!fs8.existsSync(runtimeDir)) fs8.mkdirSync(runtimeDir, { recursive: true });
   let sequence = 1;
   while (true) {
     const id = `DISCUSSION-${String(sequence).padStart(3, "0")}`;
     const filename = `${id}-${slugifyTitle(title)}.md`;
-    const summaryRelativePath = path6.join(".optima", "tasks", "discussions", filename);
-    const summaryAbsolutePath = path6.join(worktree, summaryRelativePath);
+    const summaryRelativePath = path8.join(".optima", "tasks", "discussions", filename);
+    const summaryAbsolutePath = path8.join(worktree, summaryRelativePath);
     const transcriptFilename = `${id}-transcript.md`;
-    const transcriptRelativePath = path6.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
-    const transcriptAbsolutePath = path6.join(worktree, transcriptRelativePath);
-    if (!fs5.existsSync(summaryAbsolutePath) && !fs5.existsSync(transcriptAbsolutePath)) {
+    const transcriptRelativePath = path8.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
+    const transcriptAbsolutePath = path8.join(worktree, transcriptRelativePath);
+    if (!fs8.existsSync(summaryAbsolutePath) && !fs8.existsSync(transcriptAbsolutePath)) {
       return {
         id,
         filename,
@@ -13021,23 +13264,23 @@ function nextDiscussionIdentity(worktree, title) {
 }
 function findDiscussionById(worktree, discussionID) {
   const discussionsDir = finalDiscussionsDir(worktree);
-  if (!fs5.existsSync(discussionsDir)) return null;
-  const entries = fs5.readdirSync(discussionsDir).filter((name) => name.startsWith(`${discussionID}-`) && name.endsWith(".md"));
+  if (!fs8.existsSync(discussionsDir)) return null;
+  const entries = fs8.readdirSync(discussionsDir).filter((name) => name.startsWith(`${discussionID}-`) && name.endsWith(".md"));
   if (entries.length === 0) return null;
   const filename = entries.sort()[0];
   const transcriptFilename = `${discussionID}-transcript.md`;
   return {
     id: discussionID,
     filename,
-    summaryRelativePath: path6.join(".optima", "tasks", "discussions", filename),
-    summaryAbsolutePath: path6.join(discussionsDir, filename),
+    summaryRelativePath: path8.join(".optima", "tasks", "discussions", filename),
+    summaryAbsolutePath: path8.join(discussionsDir, filename),
     transcriptFilename,
-    transcriptRelativePath: path6.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
-    transcriptAbsolutePath: path6.join(runtimeDiscussionsDir(worktree), transcriptFilename)
+    transcriptRelativePath: path8.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
+    transcriptAbsolutePath: path8.join(runtimeDiscussionsDir(worktree), transcriptFilename)
   };
 }
 function parseDiscussionFile(filePath) {
-  const raw = fs5.readFileSync(filePath, "utf8");
+  const raw = fs8.readFileSync(filePath, "utf8");
   const { data, body } = parseFrontmatter(raw);
   return { data, body: body.trimStart() };
 }
@@ -13048,10 +13291,10 @@ ${import_yaml3.default.stringify(frontmatter).trim()}
 
 ${body.trimEnd()}
 `;
-  fs5.writeFileSync(filePath, serialized, "utf8");
+  fs8.writeFileSync(filePath, serialized, "utf8");
 }
 function setDiscussionStatus(filePath, status) {
-  if (!fs5.existsSync(filePath)) return;
+  if (!fs8.existsSync(filePath)) return;
   const { data, body } = parseDiscussionFile(filePath);
   writeDiscussionFile(filePath, { ...data, status }, body);
 }
@@ -13116,18 +13359,18 @@ async function appendMessageIfNeeded(client, worktree, registry, sessionID, mess
   });
   const text = extractTextParts(response.data.parts || []);
   if (!text) return;
-  appendDiscussionMessage(path6.join(worktree, discussion.transcriptPath), speaker, text, messageID);
+  appendDiscussionMessage(path8.join(worktree, discussion.transcriptPath), speaker, text, messageID);
   discussion.appendedMessageIDs ??= [];
   discussion.appendedMessageIDs.push(messageID);
   saveDiscussionRegistry(worktree, registry);
 }
 async function summarizeDiscussionWithBA(client, worktree, discussion) {
-  const transcriptPath = path6.join(worktree, discussion.transcriptPath);
-  const summaryPath = path6.join(worktree, discussion.summaryPath);
-  const summaryDir = path6.dirname(summaryPath);
-  if (!fs5.existsSync(summaryDir)) fs5.mkdirSync(summaryDir, { recursive: true });
-  const hasExistingSummary = fs5.existsSync(summaryPath);
-  const priorMtimeMs = hasExistingSummary ? fs5.statSync(summaryPath).mtimeMs : null;
+  const transcriptPath = path8.join(worktree, discussion.transcriptPath);
+  const summaryPath = path8.join(worktree, discussion.summaryPath);
+  const summaryDir = path8.dirname(summaryPath);
+  if (!fs8.existsSync(summaryDir)) fs8.mkdirSync(summaryDir, { recursive: true });
+  const hasExistingSummary = fs8.existsSync(summaryPath);
+  const priorMtimeMs = hasExistingSummary ? fs8.statSync(summaryPath).mtimeMs : null;
   const summarizerSession = await client.session.create({
     body: { title: `Discussion Summary: ${discussion.id}` }
   });
@@ -13227,30 +13470,30 @@ async function summarizeDiscussionWithBA(client, worktree, discussion) {
   return { confirmation, summaryPath, transcriptPath, hasExistingSummary, priorMtimeMs };
 }
 function archiveDiscussionTranscript(worktree, transcriptRelativePath) {
-  const sourcePath = path6.join(worktree, transcriptRelativePath);
-  if (!fs5.existsSync(sourcePath)) return null;
+  const sourcePath = path8.join(worktree, transcriptRelativePath);
+  if (!fs8.existsSync(sourcePath)) return null;
   const archiveDir = archivedRuntimeDiscussionsDir(worktree);
-  if (!fs5.existsSync(archiveDir)) fs5.mkdirSync(archiveDir, { recursive: true });
-  const targetPath = path6.join(archiveDir, path6.basename(sourcePath));
-  fs5.renameSync(sourcePath, targetPath);
+  if (!fs8.existsSync(archiveDir)) fs8.mkdirSync(archiveDir, { recursive: true });
+  const targetPath = path8.join(archiveDir, path8.basename(sourcePath));
+  fs8.renameSync(sourcePath, targetPath);
   return targetPath;
 }
 async function finalizeClosingDiscussion(client, worktree, registry, sessionID, discussion) {
   const { confirmation, summaryPath, hasExistingSummary, priorMtimeMs } = await summarizeDiscussionWithBA(client, worktree, discussion);
-  if (!fs5.existsSync(summaryPath)) {
+  if (!fs8.existsSync(summaryPath)) {
     throw new Error(`Discussion summary was not written to ${discussion.summaryPath}`);
   }
   if (hasExistingSummary) {
-    const currentMtimeMs = fs5.statSync(summaryPath).mtimeMs;
+    const currentMtimeMs = fs8.statSync(summaryPath).mtimeMs;
     if (currentMtimeMs <= priorMtimeMs) {
       throw new Error(`Discussion summary file was not updated at ${discussion.summaryPath}`);
     }
   }
-  const summaryContent = fs5.readFileSync(summaryPath, "utf8").trim();
+  const summaryContent = fs8.readFileSync(summaryPath, "utf8").trim();
   if (!summaryContent) {
     throw new Error(`Discussion summary file is empty at ${discussion.summaryPath}`);
   }
-  const transcriptPath = path6.join(worktree, discussion.transcriptPath);
+  const transcriptPath = path8.join(worktree, discussion.transcriptPath);
   setDiscussionStatus(transcriptPath, "closed");
   const archivedTranscriptPath = archiveDiscussionTranscript(worktree, discussion.transcriptPath);
   delete registry.active[sessionID];
@@ -13258,7 +13501,7 @@ async function finalizeClosingDiscussion(client, worktree, registry, sessionID,
   return {
     confirmation,
     summaryPath: discussion.summaryPath,
-    archivedTranscriptPath: archivedTranscriptPath ? path6.relative(worktree, archivedTranscriptPath) : path6.join(".optima", ".config", "runtime", "discussions", "archive", path6.basename(discussion.transcriptPath))
+    archivedTranscriptPath: archivedTranscriptPath ? path8.relative(worktree, archivedTranscriptPath) : path8.join(".optima", ".config", "runtime", "discussions", "archive", path8.basename(discussion.transcriptPath))
   };
 }
 function normalizeTeamMode(value) {
@@ -13297,13 +13540,13 @@ function getOperatingTeamMode(repoCfg) {
 }
 function readResolvedFile(relativePath, worktree, options = {}) {
   const filePath = resolveIncludeFile(`plugin:${relativePath}`, worktree, PKG_ROOT, options);
-  if (!filePath || !fs5.existsSync(filePath)) return "";
-  return resolveIncludes(fs5.readFileSync(filePath, "utf8"), worktree, PKG_ROOT, options).trim();
+  if (!filePath || !fs8.existsSync(filePath)) return "";
+  return resolveIncludes(fs8.readFileSync(filePath, "utf8"), worktree, PKG_ROOT, options).trim();
 }
 function loadMarkdownFragment(filePath, worktree) {
-  if (!fs5.existsSync(filePath)) return "";
+  if (!fs8.existsSync(filePath)) return "";
   try {
-    const raw = fs5.readFileSync(filePath, "utf8");
+    const raw = fs8.readFileSync(filePath, "utf8");
     const { body } = parseFrontmatter(raw);
     return resolveIncludes(body.trim(), worktree, PKG_ROOT);
   } catch (e) {
@@ -13312,9 +13555,9 @@ function loadMarkdownFragment(filePath, worktree) {
   }
 }
 function loadAgentDefinition(filePath, worktree, options = {}) {
-  if (!fs5.existsSync(filePath)) return null;
+  if (!fs8.existsSync(filePath)) return null;
   try {
-    const rawContent = fs5.readFileSync(filePath, "utf8");
+    const rawContent = fs8.readFileSync(filePath, "utf8");
     const { data, body } = parseFrontmatter(rawContent);
     const prompt = resolveIncludes(body.trim(), worktree, PKG_ROOT, options);
     return { data, prompt };
@@ -13325,13 +13568,13 @@ function loadAgentDefinition(filePath, worktree, options = {}) {
 }
 function syncGeneratedPolicies(worktree, repoCfg) {
   if (repoCfg.policies?.extract_defaults !== "all") return;
-  if (!fs5.existsSync(BUNDLE_POLICIES_DIR)) return;
+  if (!fs8.existsSync(BUNDLE_POLICIES_DIR)) return;
   const generatedDir = generatedPoliciesDir(worktree);
-  if (!fs5.existsSync(generatedDir)) fs5.mkdirSync(generatedDir, { recursive: true });
-  const policyFiles = fs5.readdirSync(BUNDLE_POLICIES_DIR).filter((file) => file.endsWith(".md") && file !== "README.md");
+  if (!fs8.existsSync(generatedDir)) fs8.mkdirSync(generatedDir, { recursive: true });
+  const policyFiles = fs8.readdirSync(BUNDLE_POLICIES_DIR).filter((file) => file.endsWith(".md") && file !== "README.md");
   for (const file of policyFiles) {
-    const sourcePath = path6.join(BUNDLE_POLICIES_DIR, file);
-    const source = fs5.readFileSync(sourcePath, "utf8").trimEnd();
+    const sourcePath = path8.join(BUNDLE_POLICIES_DIR, file);
+    const source = fs8.readFileSync(sourcePath, "utf8").trimEnd();
     const generated = [
       "<!--",
       "Generated from Optima plugin defaults.",
@@ -13342,19 +13585,19 @@ function syncGeneratedPolicies(worktree, repoCfg) {
       source,
       ""
     ].join("\n");
-    fs5.writeFileSync(path6.join(generatedDir, file), generated, "utf8");
+    fs8.writeFileSync(path8.join(generatedDir, file), generated, "utf8");
   }
 }
 function ensureReadmeFile(dirPath, content) {
-  if (!fs5.existsSync(dirPath)) fs5.mkdirSync(dirPath, { recursive: true });
-  const readmePath = path6.join(dirPath, "README.md");
-  if (!fs5.existsSync(readmePath)) {
-    fs5.writeFileSync(readmePath, content, "utf8");
+  if (!fs8.existsSync(dirPath)) fs8.mkdirSync(dirPath, { recursive: true });
+  const readmePath = path8.join(dirPath, "README.md");
+  if (!fs8.existsSync(readmePath)) {
+    fs8.writeFileSync(readmePath, content, "utf8");
   }
 }
 function ensureFileIfMissing(filePath, content) {
-  if (!fs5.existsSync(path6.dirname(filePath))) fs5.mkdirSync(path6.dirname(filePath), { recursive: true });
-  if (!fs5.existsSync(filePath)) fs5.writeFileSync(filePath, content, "utf8");
+  if (!fs8.existsSync(path8.dirname(filePath))) fs8.mkdirSync(path8.dirname(filePath), { recursive: true });
+  if (!fs8.existsSync(filePath)) fs8.writeFileSync(filePath, content, "utf8");
 }
 function currentTasksRegistryContent() {
   return "# Current Tasks (Backlog)\n\n## \u{1F4AC} Active Discussions\n- (None)\n\n## \u{1F680} Active\n- (None)\n\n## \u{1F4CB} Todo\n- (None)\n\n## \u{1F6D1} Blocked\n- (None)\n";
@@ -13440,16 +13683,16 @@ Never place implementation evidence under root \`evidences/\`.
 }
 function ensureOptimaTaskTemplates(worktree) {
   const tasksDir = optimaTasksDir(worktree);
-  ensureFileIfMissing(path6.join(tasksDir, "task-template.md"), taskTemplateContent());
-  ensureFileIfMissing(path6.join(tasksDir, "subtask-template.md"), subtaskTemplateContent());
+  ensureFileIfMissing(path8.join(tasksDir, "task-template.md"), taskTemplateContent());
+  ensureFileIfMissing(path8.join(tasksDir, "subtask-template.md"), subtaskTemplateContent());
 }
 function scaffoldOptimaConfig(worktree, teamMode = "full") {
   const configPath = repoConfigPath(worktree);
-  if (fs5.existsSync(configPath)) return false;
-  const templatePath = path6.join(TEMPLATES_DIR, "optima.yaml.template");
-  if (!fs5.existsSync(templatePath)) return false;
-  const agentIds = fs5.existsSync(BUNDLE_AGENTS_DIR) ? fs5.readdirSync(BUNDLE_AGENTS_DIR).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")) : [];
-  let optimaConfig = fs5.readFileSync(templatePath, "utf8");
+  if (fs8.existsSync(configPath)) return false;
+  const templatePath = path8.join(TEMPLATES_DIR, "optima.yaml.template");
+  if (!fs8.existsSync(templatePath)) return false;
+  const agentIds = fs8.existsSync(BUNDLE_AGENTS_DIR) ? fs8.readdirSync(BUNDLE_AGENTS_DIR).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")) : [];
+  let optimaConfig = fs8.readFileSync(templatePath, "utf8");
   optimaConfig = optimaConfig.replace("{{teamMode}}", normalizeTeamMode(teamMode));
   let agentsSection = "";
   for (const id of agentIds) {
@@ -13460,26 +13703,26 @@ function scaffoldOptimaConfig(worktree, teamMode = "full") {
   }
   optimaConfig = optimaConfig.replace(/^agents:/m, "agents:\n" + agentsSection);
   ensureFileIfMissing(configPath, optimaConfig);
-  return fs5.existsSync(configPath);
+  return fs8.existsSync(configPath);
 }
 function scaffoldOptimaRootCodemap(worktree) {
   const rootCodemapPath = optimaCodemapPath(worktree);
-  if (fs5.existsSync(rootCodemapPath)) return false;
-  const templatePath = path6.join(TEMPLATES_DIR, "codemap.yml.template");
-  if (!fs5.existsSync(templatePath)) return false;
-  const codemapConfig = fs5.readFileSync(templatePath, "utf8").replace("{{projectName}}", path6.basename(worktree));
+  if (fs8.existsSync(rootCodemapPath)) return false;
+  const templatePath = path8.join(TEMPLATES_DIR, "codemap.yml.template");
+  if (!fs8.existsSync(templatePath)) return false;
+  const codemapConfig = fs8.readFileSync(templatePath, "utf8").replace("{{projectName}}", path8.basename(worktree));
   ensureFileIfMissing(rootCodemapPath, codemapConfig);
-  return fs5.existsSync(rootCodemapPath);
+  return fs8.existsSync(rootCodemapPath);
 }
 function ensureOptimaRegistries(worktree) {
   const tasksDir = optimaTasksDir(worktree);
   const scrsDir = optimaScrsDir(worktree);
-  if (!fs5.existsSync(tasksDir)) fs5.mkdirSync(tasksDir, { recursive: true });
-  if (!fs5.existsSync(scrsDir)) fs5.mkdirSync(scrsDir, { recursive: true });
-  ensureFileIfMissing(path6.join(tasksDir, "current.md"), currentTasksRegistryContent());
-  ensureFileIfMissing(path6.join(tasksDir, "done.md"), doneTasksRegistryContent());
-  ensureFileIfMissing(path6.join(scrsDir, "current.md"), currentScrRegistryContent());
-  ensureFileIfMissing(path6.join(scrsDir, "done.md"), doneScrRegistryContent());
+  if (!fs8.existsSync(tasksDir)) fs8.mkdirSync(tasksDir, { recursive: true });
+  if (!fs8.existsSync(scrsDir)) fs8.mkdirSync(scrsDir, { recursive: true });
+  ensureFileIfMissing(path8.join(tasksDir, "current.md"), currentTasksRegistryContent());
+  ensureFileIfMissing(path8.join(tasksDir, "done.md"), doneTasksRegistryContent());
+  ensureFileIfMissing(path8.join(scrsDir, "current.md"), currentScrRegistryContent());
+  ensureFileIfMissing(path8.join(scrsDir, "done.md"), doneScrRegistryContent());
 }
 function scaffoldOptimaReadmes(worktree) {
   ensureReadmeFile(repoPoliciesDir(worktree), REPO_LOCAL_POLICIES_README);
@@ -13641,12 +13884,12 @@ function shouldRegisterWorkflowProductManager(options = {}, worktree = process.c
 }
 function isClickUpDerivedWorktreeSibling(candidate, basePath) {
   if (typeof candidate !== "string" || typeof basePath !== "string" || !candidate.trim() || !basePath.trim()) return false;
-  const resolvedCandidate = path6.resolve(candidate);
-  const resolvedBase = path6.resolve(basePath);
-  const baseParent = path6.dirname(resolvedBase);
-  if (path6.dirname(resolvedCandidate) !== baseParent) return false;
-  const baseName = path6.basename(resolvedBase);
-  const candidateName = path6.basename(resolvedCandidate);
+  const resolvedCandidate = path8.resolve(candidate);
+  const resolvedBase = path8.resolve(basePath);
+  const baseParent = path8.dirname(resolvedBase);
+  if (path8.dirname(resolvedCandidate) !== baseParent) return false;
+  const baseName = path8.basename(resolvedBase);
+  const candidateName = path8.basename(resolvedCandidate);
   if (!candidateName.startsWith(`${baseName}-`)) return false;
   const branchSlug = candidateName.slice(baseName.length + 1);
   const parts = branchSlug.split("-").filter(Boolean);
@@ -13654,11 +13897,11 @@ function isClickUpDerivedWorktreeSibling(candidate, basePath) {
   if (!(/* @__PURE__ */ new Set(["tarea", "bug", "doc", "poc", "idea"])).has(parts[0])) return false;
   if (!parts.slice(1).every((part) => /^[a-z0-9][a-z0-9-]*$/.test(part))) return false;
   try {
-    const candidateStat = fs5.lstatSync(resolvedCandidate);
+    const candidateStat = fs8.lstatSync(resolvedCandidate);
     if (!candidateStat.isDirectory() || candidateStat.isSymbolicLink()) return false;
-    const realCandidate = fs5.realpathSync.native(resolvedCandidate);
-    const realBaseParent = fs5.realpathSync.native(baseParent);
-    return path6.dirname(realCandidate) === realBaseParent && path6.basename(realCandidate) === candidateName;
+    const realCandidate = fs8.realpathSync.native(resolvedCandidate);
+    const realBaseParent = fs8.realpathSync.native(baseParent);
+    return path8.dirname(realCandidate) === realBaseParent && path8.basename(realCandidate) === candidateName;
   } catch {
     return false;
   }
@@ -13666,15 +13909,15 @@ function isClickUpDerivedWorktreeSibling(candidate, basePath) {
 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() ? path6.resolve(safe.worktree, String(requestedDirectory).trim()) : safe.worktree;
+  const requested = String(requestedDirectory || "").trim() ? path8.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: path6.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path8.resolve(clickUpBasePath) };
   }
   if (clickUpBasePath && isClickUpDerivedWorktreeSibling(requested, clickUpBasePath)) {
-    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path6.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path8.resolve(clickUpBasePath) };
   }
   return {
     ok: false,
@@ -13708,8 +13951,8 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
       if (!enabled) continue;
     }
     const promptOptions = { preferCompactPromptDocs: repoCfg.features?.compact_prompt_docs !== false };
-    const bundledDefinition = loadAgentDefinition(path6.join(BUNDLE_AGENTS_DIR, file), worktree, promptOptions);
-    const repoDefinition = loadAgentDefinition(path6.join(repoAgentDefinitions, file), worktree, promptOptions) || loadAgentDefinition(path6.join(legacyAgentsDir, file), worktree, promptOptions);
+    const bundledDefinition = loadAgentDefinition(path8.join(BUNDLE_AGENTS_DIR, file), worktree, promptOptions);
+    const repoDefinition = loadAgentDefinition(path8.join(repoAgentDefinitions, file), worktree, promptOptions) || loadAgentDefinition(path8.join(legacyAgentsDir, file), worktree, promptOptions);
     const activeDefinition = repoDefinition || bundledDefinition;
     if (!activeDefinition) continue;
     const { data } = activeDefinition;
@@ -13718,7 +13961,7 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
     if (modePromptFragment) finalPrompt = `${finalPrompt}
 
 ${modePromptFragment}`;
-    const additionFragment = loadMarkdownFragment(path6.join(repoAgentAdditions, file), worktree);
+    const additionFragment = loadMarkdownFragment(path8.join(repoAgentAdditions, file), worktree);
     if (additionFragment) {
       finalPrompt = `${finalPrompt}
 
@@ -13771,14 +14014,14 @@ Use this Optima-provided fallback when the current task worktree lacks docs/core
     }
     ourAgents[id] = agentConfig;
     if (repoCfg.features?.debug_dumps !== false) {
-      const debugPath = path6.join(debugDir, `${id}.md`);
+      const debugPath = path8.join(debugDir, `${id}.md`);
       const { prompt, ...dumpConfig } = agentConfig;
       const debugHeader = `---
 ${import_yaml3.default.stringify(dumpConfig).trim()}
 ---`;
       try {
-        if (!fs5.existsSync(debugDir)) fs5.mkdirSync(debugDir, { recursive: true });
-        fs5.writeFileSync(debugPath, `${debugHeader}
+        if (!fs8.existsSync(debugDir)) fs8.mkdirSync(debugDir, { recursive: true });
+        fs8.writeFileSync(debugPath, `${debugHeader}
 
 ${prompt}`, "utf8");
       } catch (e) {
@@ -13802,9 +14045,9 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   const configPath = resolveConfigPath(worktree);
   const discussionRegistry = loadDiscussionRegistry(worktree);
   let repoCfg = { agents: {}, defaults: {}, features: {} };
-  if (fs5.existsSync(configPath)) {
+  if (fs8.existsSync(configPath)) {
     try {
-      repoCfg = import_yaml3.default.parse(fs5.readFileSync(configPath, "utf8")) || repoCfg;
+      repoCfg = import_yaml3.default.parse(fs8.readFileSync(configPath, "utf8")) || repoCfg;
     } catch (e) {
       console.error(`[Optima] Failed to parse config at ${configPath}:`, e);
     }
@@ -13932,10 +14175,10 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
         }
         migrateLegacyOptimaLayout(toolWorktree);
         const cfgDir = optimaConfigDir(toolWorktree);
-        if (!fs5.existsSync(cfgDir)) fs5.mkdirSync(cfgDir, { recursive: true });
-        const optimaTmplPath = path6.join(TEMPLATES_DIR, "optima.yaml.template");
-        const codemapTmplPath = path6.join(TEMPLATES_DIR, "codemap.yml.template");
-        if (!fs5.existsSync(optimaTmplPath) || !fs5.existsSync(codemapTmplPath)) {
+        if (!fs8.existsSync(cfgDir)) fs8.mkdirSync(cfgDir, { recursive: true });
+        const optimaTmplPath = path8.join(TEMPLATES_DIR, "optima.yaml.template");
+        const codemapTmplPath = path8.join(TEMPLATES_DIR, "codemap.yml.template");
+        if (!fs8.existsSync(optimaTmplPath) || !fs8.existsSync(codemapTmplPath)) {
           return "Error: Initialization templates not found in plugin.";
         }
         scaffoldOptimaConfig(toolWorktree, requestedTeamMode);
@@ -14056,14 +14299,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 = path6.resolve(safe.worktree, args.summary_path || "");
-        if (!fs5.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
-        const taskPath = args.task_path ? path6.resolve(safe.worktree, args.task_path) : "";
+        const summaryPath = path8.resolve(safe.worktree, args.summary_path || "");
+        if (!fs8.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
+        const taskPath = args.task_path ? path8.resolve(safe.worktree, args.task_path) : "";
         const payload = buildClickUpSummaryPayload({
-          summaryMarkdown: fs5.readFileSync(summaryPath, "utf8"),
-          summaryPath: path6.relative(safe.worktree, summaryPath),
-          taskMarkdown: taskPath && fs5.existsSync(taskPath) ? fs5.readFileSync(taskPath, "utf8") : "",
-          taskPath: taskPath ? path6.relative(safe.worktree, taskPath) : "",
+          summaryMarkdown: fs8.readFileSync(summaryPath, "utf8"),
+          summaryPath: path8.relative(safe.worktree, summaryPath),
+          taskMarkdown: taskPath && fs8.existsSync(taskPath) ? fs8.readFileSync(taskPath, "utf8") : "",
+          taskPath: taskPath ? path8.relative(safe.worktree, taskPath) : "",
           branch: args.branch,
           worktree: args.worktree,
           pr: args.pr
@@ -14142,12 +14385,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 = path6.resolve(safe.worktree, args.markdown_path || "");
-        if (!fs5.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
+        const markdownPath = path8.resolve(safe.worktree, args.markdown_path || "");
+        if (!fs8.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
         const payload = buildClickUpCreateSubtasksPayload({
           parentTaskId: args.parent_task_id,
-          markdown: fs5.readFileSync(markdownPath, "utf8"),
-          sourcePath: path6.relative(safe.worktree, markdownPath),
+          markdown: fs8.readFileSync(markdownPath, "utf8"),
+          sourcePath: path8.relative(safe.worktree, markdownPath),
           parentBranch: args.parent_branch,
           parentTaskType: args.parent_task_type || "Tarea",
           apply: String(args.apply || "").toLowerCase() === "true"
@@ -14263,6 +14506,31 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
         }
       }
     }),
+    optima_github_verify_vercel_pr: tool({
+      description: "Verify that a PR head commit has a successful Vercel preproduction deployment and a functional deployment URL before validation/handoff",
+      args: {
+        pr_number: tool.schema.number().describe("Pull request number"),
+        context: tool.schema.string().describe("Required GitHub status context; defaults to 'Vercel \u2013 defend-preproduction'"),
+        environment: tool.schema.string().describe("Required GitHub deployment environment; defaults to 'Preview \u2013 defend-preproduction'"),
+        require_functional_url: tool.schema.string().describe("Set to 'false' to skip HTTP probing of the deployment URL")
+      },
+      async execute(args) {
+        try {
+          const auth = await requireGitHubAppClient();
+          if (!auth.ok) return JSON.stringify(auth, null, 2);
+          if (!runtimeGitHubClient?.verifyVercelPullRequestDeployment) return JSON.stringify({ ok: false, error: "github_client_unavailable" }, null, 2);
+          const result = await runtimeGitHubClient.verifyVercelPullRequestDeployment({
+            pullNumber: args.pr_number,
+            context: args.context || "Vercel \u2013 defend-preproduction",
+            environment: args.environment || "Preview \u2013 defend-preproduction",
+            requireFunctionalUrl: String(args.require_functional_url || "true").toLowerCase() !== "false"
+          });
+          return JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message }, null, 2);
+        }
+      }
+    }),
     optima_github_merge_pr: tool({
       description: "Merge a GitHub PR through the Optima GitHub App identity after required human approval gates pass",
       args: {
@@ -14492,7 +14760,7 @@ Backfilled messages: ${backfilled}`;
         if (!existing) {
           return "FAIL: No active discussion exists for this session.";
         }
-        const discussionPath = path6.join(toolWorktree, existing.transcriptPath);
+        const discussionPath = path8.join(toolWorktree, existing.transcriptPath);
         setDiscussionStatus(discussionPath, "summarizing");
         existing.status = "summarizing";
         saveDiscussionRegistry(toolWorktree, toolRegistry);
@@ -14544,7 +14812,7 @@ Reason: ${err.message}`;
         try {
           const sessionResult = await client.session.create({
             query: { directory: workflowDirectory },
-            body: { title: `Workflow Run: ${path6.basename(workflowTaskPath)}` }
+            body: { title: `Workflow Run: ${path8.basename(workflowTaskPath)}` }
           });
           const sessionId = sessionResult.data.id;
           activeWorkflows.set(sessionId, { pmaSessionId, taskPath: workflowTaskPath, track: workflowTrack, directory: workflowDirectory });
@@ -14728,14 +14996,14 @@ function usage() {
   ].join("\n");
 }
 function expandHome(inputPath) {
-  if (!inputPath || inputPath === "~") return os2.homedir();
-  if (inputPath.startsWith("~/")) return path7.join(os2.homedir(), inputPath.slice(2));
+  if (!inputPath || inputPath === "~") return os3.homedir();
+  if (inputPath.startsWith("~/")) return path9.join(os3.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 (fs6.existsSync(expanded) && fs6.statSync(expanded).isDirectory()) return path7.join(expanded, "opencode.db");
+    if (fs9.existsSync(expanded) && fs9.statSync(expanded).isDirectory()) return path9.join(expanded, "opencode.db");
   } catch {
     return expanded;
   }
@@ -14799,12 +15067,12 @@ function extractOpenedPathValue(value) {
 }
 function normalizePathCandidate(candidate) {
   const expanded = expandHome(candidate);
-  if (!path7.isAbsolute(expanded)) return null;
-  return path7.resolve(expanded);
+  if (!path9.isAbsolute(expanded)) return null;
+  return path9.resolve(expanded);
 }
 function discoverOpenCodePaths(dbPath) {
   const resolvedDb = resolveOpenCodeDbPath(dbPath);
-  if (!fs6.existsSync(resolvedDb)) throw new Error(`OpenCode database not found: ${resolvedDb}`);
+  if (!fs9.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) {
@@ -14829,27 +15097,27 @@ function discoverOpenCodePaths(dbPath) {
 function collectMarkdownOverridesFrom(baseDir) {
   const files = [];
   for (const dirName of OVERRIDE_DIRS) {
-    const dirPath = path7.join(baseDir, dirName);
-    if (!fs6.existsSync(dirPath)) continue;
-    for (const entry of fs6.readdirSync(dirPath, { withFileTypes: true })) {
+    const dirPath = path9.join(baseDir, dirName);
+    if (!fs9.existsSync(dirPath)) continue;
+    for (const entry of fs9.readdirSync(dirPath, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".md")) continue;
       if (entry.name.toLowerCase() === "readme.md") continue;
-      files.push(path7.join(dirPath, entry.name));
+      files.push(path9.join(dirPath, entry.name));
     }
   }
   return files;
 }
 function collectOverrideFiles(worktree) {
-  return collectMarkdownOverridesFrom(path7.join(worktree, ".optima")).sort();
+  return collectMarkdownOverridesFrom(path9.join(worktree, ".optima")).sort();
 }
 function collectPlannedOverrideFiles(worktree) {
   return [
     ...collectOverrideFiles(worktree),
-    ...collectMarkdownOverridesFrom(path7.join(worktree, ".staticeng")),
-    ...collectMarkdownOverridesFrom(path7.join(worktree, ".orbita")),
-    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadwork")),
-    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadworks"))
+    ...collectMarkdownOverridesFrom(path9.join(worktree, ".staticeng")),
+    ...collectMarkdownOverridesFrom(path9.join(worktree, ".orbita")),
+    ...collectMarkdownOverridesFrom(path9.join(worktree, ".nomadwork")),
+    ...collectMarkdownOverridesFrom(path9.join(worktree, ".nomadworks"))
   ].sort();
 }
 var CRC_TABLE = (() => {
@@ -14882,14 +15150,14 @@ function writeUInt16LE(value) {
   return buffer;
 }
 function createZipBackup(files, backupPath) {
-  fs6.mkdirSync(path7.dirname(backupPath), { recursive: true });
+  fs9.mkdirSync(path9.dirname(backupPath), { recursive: true });
   const localParts = [];
   const centralParts = [];
   let offset = 0;
   const now = dosTimeDate();
   for (const filePath of files) {
-    const data = fs6.readFileSync(filePath);
-    const name = path7.resolve(filePath).replace(/^\//, "").split(path7.sep).join("/");
+    const data = fs9.readFileSync(filePath);
+    const name = path9.resolve(filePath).replace(/^\//, "").split(path9.sep).join("/");
     const nameBuffer = Buffer.from(name, "utf8");
     const crc = crc32(data);
     const local = Buffer.concat([
@@ -14941,7 +15209,7 @@ function createZipBackup(files, backupPath) {
     writeUInt32LE(offset),
     writeUInt16LE(0)
   ]);
-  fs6.writeFileSync(backupPath, Buffer.concat([...localParts, ...centralParts, end]));
+  fs9.writeFileSync(backupPath, Buffer.concat([...localParts, ...centralParts, end]));
 }
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
@@ -14951,17 +15219,17 @@ function validationStatus(result) {
   return result.ok ? "passed" : "failed";
 }
 function hasLegacyMarker(worktree) {
-  return fs6.existsSync(path7.join(worktree, ".staticeng")) || fs6.existsSync(path7.join(worktree, ".orbita")) || fs6.existsSync(path7.join(worktree, ".nomadwork")) || fs6.existsSync(path7.join(worktree, ".nomadworks"));
+  return fs9.existsSync(path9.join(worktree, ".staticeng")) || fs9.existsSync(path9.join(worktree, ".orbita")) || fs9.existsSync(path9.join(worktree, ".nomadwork")) || fs9.existsSync(path9.join(worktree, ".nomadworks"));
 }
 function rootOptimaArtifacts(worktree) {
   const artifacts = [
-    ["tasks/", path7.join(worktree, "tasks")],
-    ["evidences/", path7.join(worktree, "evidences")],
-    ["docs/scrs/", path7.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path7.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path7.join(worktree, "codemap.yaml")]
+    ["tasks/", path9.join(worktree, "tasks")],
+    ["evidences/", path9.join(worktree, "evidences")],
+    ["docs/scrs/", path9.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path9.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path9.join(worktree, "codemap.yaml")]
   ];
-  return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs6.existsSync(item.path));
+  return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs9.existsSync(item.path));
 }
 function hasSanitizableOverrides(worktree) {
   return collectPlannedOverrideFiles(worktree).length > 0;
@@ -14987,7 +15255,7 @@ function planOptimaMigration(worktree, dryRun) {
       ...overrides.map((file) => ({
         category: "override",
         action: dryRun ? "would_remove_after_backup" : "removed_after_backup",
-        path: path7.relative(worktree, file).split(path7.sep).join("/"),
+        path: path9.relative(worktree, file).split(path9.sep).join("/"),
         detail: "Remove implicit agent/policy override after host-level backup."
       }))
     ],
@@ -15008,12 +15276,12 @@ async function sanitizeHost(options = {}) {
   const repoStates = [];
   for (const candidate of paths) {
     try {
-      if (!fs6.existsSync(candidate)) {
+      if (!fs9.existsSync(candidate)) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "missing" });
         continue;
       }
-      if (!fs6.statSync(candidate).isDirectory()) {
+      if (!fs9.statSync(candidate).isDirectory()) {
         report.totals.skipped += 1;
         report.repos.push({ path: candidate, status: "skipped", reason: "not_directory" });
         continue;
@@ -15035,7 +15303,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 = path7.join(os2.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
+    const backupPath = path9.join(os3.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
     try {
       createZipBackup(overrides.map((item) => item.file), backupPath);
       report.backupPath = backupPath;
@@ -15051,7 +15319,7 @@ async function sanitizeHost(options = {}) {
   for (const state of repoStates) {
     try {
       if (!dryRun) {
-        for (const file of state.overrideFiles) fs6.rmSync(file, { force: true });
+        for (const file of state.overrideFiles) fs9.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";
@@ -15064,7 +15332,7 @@ async function sanitizeHost(options = {}) {
         repairActions: state.plan.actions.length,
         repairSkipped: state.plan.skippedRepair === true,
         overrideFiles: state.overrideFiles.length,
-        overridePaths: state.overrideFiles.map((file) => path7.relative(state.repo, file).split(path7.sep).join("/")),
+        overridePaths: state.overrideFiles.map((file) => path9.relative(state.repo, file).split(path9.sep).join("/")),
         validation: validation ? validationStatus(validation) : "skipped",
         unresolved: state.plan.unresolved
       });