@defend-tech/opencode-optima 0.1.55 → 0.1.57

package/dist/index.js

@@ -108,17 +108,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path3) {
-      const ctrl = callVisitor(key, node, visitor, path3);
+    function visit_(key, node, visitor, path6) {
+      const ctrl = callVisitor(key, node, visitor, path6);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path3, ctrl);
-        return visit_(key, ctrl, visitor, path3);
+        replaceNode(key, path6, ctrl);
+        return visit_(key, ctrl, visitor, path6);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path3 = Object.freeze(path3.concat(node));
+          path6 = Object.freeze(path6.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path3);
+            const ci = visit_(i, node.items[i], visitor, path6);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -129,13 +129,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path3 = Object.freeze(path3.concat(node));
-          const ck = visit_("key", node.key, visitor, path3);
+          path6 = Object.freeze(path6.concat(node));
+          const ck = visit_("key", node.key, visitor, path6);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path3);
+          const cv = visit_("value", node.value, visitor, path6);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -156,17 +156,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path3) {
-      const ctrl = await callVisitor(key, node, visitor, path3);
+    async function visitAsync_(key, node, visitor, path6) {
+      const ctrl = await callVisitor(key, node, visitor, path6);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path3, ctrl);
-        return visitAsync_(key, ctrl, visitor, path3);
+        replaceNode(key, path6, ctrl);
+        return visitAsync_(key, ctrl, visitor, path6);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path3 = Object.freeze(path3.concat(node));
+          path6 = Object.freeze(path6.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path3);
+            const ci = await visitAsync_(i, node.items[i], visitor, path6);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -177,13 +177,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path3 = Object.freeze(path3.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path3);
+          path6 = Object.freeze(path6.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path6);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path3);
+          const cv = await visitAsync_("value", node.value, visitor, path6);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -210,23 +210,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path3) {
+    function callVisitor(key, node, visitor, path6) {
       if (typeof visitor === "function")
-        return visitor(key, node, path3);
+        return visitor(key, node, path6);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path3);
+        return visitor.Map?.(key, node, path6);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path3);
+        return visitor.Seq?.(key, node, path6);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path3);
+        return visitor.Pair?.(key, node, path6);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path3);
+        return visitor.Scalar?.(key, node, path6);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path3);
+        return visitor.Alias?.(key, node, path6);
       return void 0;
     }
-    function replaceNode(key, path3, node) {
-      const parent = path3[path3.length - 1];
+    function replaceNode(key, path6, node) {
+      const parent = path6[path6.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -632,6 +632,8 @@ var require_Alias = __commonJS({
        * instance of the `source` anchor before this node.
        */
       resolve(doc, ctx) {
+        if (ctx?.maxAliasCount === 0)
+          throw new ReferenceError("Alias resolution is disabled");
         let nodes;
         if (ctx?.aliasResolveCache) {
           nodes = ctx.aliasResolveCache;
@@ -834,10 +836,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path3, value) {
+    function collectionFromPath(schema, path6, value) {
       let v = value;
-      for (let i = path3.length - 1; i >= 0; --i) {
-        const k = path3[i];
+      for (let i = path6.length - 1; i >= 0; --i) {
+        const k = path6[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -856,7 +858,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path3) => path3 == null || typeof path3 === "object" && !!path3[Symbol.iterator]().next().done;
+    var isEmptyPath = (path6) => path6 == null || typeof path6 === "object" && !!path6[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -886,11 +888,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(path3, value) {
-        if (isEmptyPath(path3))
+      addIn(path6, value) {
+        if (isEmptyPath(path6))
           this.add(value);
         else {
-          const [key, ...rest] = path3;
+          const [key, ...rest] = path6;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -904,8 +906,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path3) {
-        const [key, ...rest] = path3;
+      deleteIn(path6) {
+        const [key, ...rest] = path6;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -919,8 +921,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path3, keepScalar) {
-        const [key, ...rest] = path3;
+      getIn(path6, keepScalar) {
+        const [key, ...rest] = path6;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -938,8 +940,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path3) {
-        const [key, ...rest] = path3;
+      hasIn(path6) {
+        const [key, ...rest] = path6;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -949,8 +951,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(path3, value) {
-        const [key, ...rest] = path3;
+      setIn(path6, value) {
+        const [key, ...rest] = path6;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -1431,6 +1433,7 @@ var require_stringify = __commonJS({
         nullStr: "null",
         simpleKeys: false,
         singleQuote: null,
+        trailingComma: false,
         trueStr: "true",
         verifyAliasOrder: true
       }, doc.schema.toStringOptions, options);
@@ -1703,18 +1706,18 @@ var require_merge = __commonJS({
     };
     var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
     function addMergeToJSMap(ctx, map, value) {
-      value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
-      if (identity.isSeq(value))
-        for (const it of value.items)
+      const source = resolveAliasValue(ctx, value);
+      if (identity.isSeq(source))
+        for (const it of source.items)
           mergeValue(ctx, map, it);
-      else if (Array.isArray(value))
-        for (const it of value)
+      else if (Array.isArray(source))
+        for (const it of source)
           mergeValue(ctx, map, it);
       else
-        mergeValue(ctx, map, value);
+        mergeValue(ctx, map, source);
     }
     function mergeValue(ctx, map, value) {
-      const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+      const source = resolveAliasValue(ctx, value);
       if (!identity.isMap(source))
         throw new Error("Merge sources must be maps or map aliases");
       const srcMap = source.toJSON(null, ctx, Map);
@@ -1735,6 +1738,9 @@ var require_merge = __commonJS({
       }
       return map;
     }
+    function resolveAliasValue(ctx, value) {
+      return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
+    }
     exports.addMergeToJSMap = addMergeToJSMap;
     exports.isMergeKey = isMergeKey;
     exports.merge = merge;
@@ -1948,12 +1954,19 @@ ${indent}${line}` : "\n";
         if (comment)
           reqNewline = true;
         let str = stringify.stringify(item, itemCtx, () => comment = null);
-        if (i < items.length - 1)
+        reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
+        if (i < items.length - 1) {
           str += ",";
+        } else if (ctx.options.trailingComma) {
+          if (ctx.options.lineWidth > 0) {
+            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
+          }
+          if (reqNewline) {
+            str += ",";
+          }
+        }
         if (comment)
           str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
-        if (!reqNewline && (lines.length > linesAtValue || str.includes("\n")))
-          reqNewline = true;
         lines.push(str);
         linesAtValue = lines.length;
       }
@@ -2365,7 +2378,7 @@ var require_stringifyNumber = __commonJS({
       if (!isFinite(num))
         return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
       let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
-      if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
+      if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
         let i = n.indexOf(".");
         if (i < 0) {
           i = n.length;
@@ -3454,9 +3467,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path3, value) {
+      addIn(path6, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path3, value);
+          this.contents.addIn(path6, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3531,14 +3544,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path3) {
-        if (Collection.isEmptyPath(path3)) {
+      deleteIn(path6) {
+        if (Collection.isEmptyPath(path6)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path3) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path6) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3553,10 +3566,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path3, keepScalar) {
-        if (Collection.isEmptyPath(path3))
+      getIn(path6, keepScalar) {
+        if (Collection.isEmptyPath(path6))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path3, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path6, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3567,10 +3580,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path3) {
-        if (Collection.isEmptyPath(path3))
+      hasIn(path6) {
+        if (Collection.isEmptyPath(path6))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path3) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path6) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3587,13 +3600,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(path3, value) {
-        if (Collection.isEmptyPath(path3)) {
+      setIn(path6, value) {
+        if (Collection.isEmptyPath(path6)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path3), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path6), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path3, value);
+          this.contents.setIn(path6, value);
         }
       }
       /**
@@ -4737,7 +4750,7 @@ var require_resolve_flow_scalar = __commonJS({
             while (next === " " || next === "	")
               next = source[++i + 1];
           } else if (next === "x" || next === "u" || next === "U") {
-            const length = { x: 2, u: 4, U: 8 }[next];
+            const length = next === "x" ? 2 : next === "u" ? 4 : 8;
             res += parseCharCode(source, i + 1, length, onError);
             i += length;
           } else {
@@ -4812,12 +4825,13 @@ var require_resolve_flow_scalar = __commonJS({
       const cc = source.substr(offset, length);
       const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
       const code = ok ? parseInt(cc, 16) : NaN;
-      if (isNaN(code)) {
+      try {
+        return String.fromCodePoint(code);
+      } catch {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
         return raw;
       }
-      return String.fromCodePoint(code);
     }
     exports.resolveFlowScalar = resolveFlowScalar;
   }
@@ -4967,17 +4981,22 @@ var require_compose_node = __commonJS({
         case "block-map":
         case "block-seq":
         case "flow-collection":
-          node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-          if (anchor)
-            node.anchor = anchor.source.substring(1);
+          try {
+            node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+            if (anchor)
+              node.anchor = anchor.source.substring(1);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            onError(token, "RESOURCE_EXHAUSTION", message);
+          }
           break;
         default: {
           const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
           onError(token, "UNEXPECTED_TOKEN", message);
-          node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
           isSrcToken = false;
         }
       }
+      node ?? (node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError));
       if (anchor && node.anchor === "")
         onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
       if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
@@ -5162,8 +5181,10 @@ ${cb}` : comment;
           }
         }
         if (afterDoc) {
-          Array.prototype.push.apply(doc.errors, this.errors);
-          Array.prototype.push.apply(doc.warnings, this.warnings);
+          for (let i = 0; i < this.errors.length; ++i)
+            doc.errors.push(this.errors[i]);
+          for (let i = 0; i < this.warnings.length; ++i)
+            doc.warnings.push(this.warnings[i]);
         } else {
           doc.errors = this.errors;
           doc.warnings = this.warnings;
@@ -5545,9 +5566,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path3) => {
+    visit.itemAtPath = (cst, path6) => {
       let item = cst;
-      for (const [field, index] of path3) {
+      for (const [field, index] of path6) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5556,23 +5577,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path3) => {
-      const parent = visit.itemAtPath(cst, path3.slice(0, -1));
-      const field = path3[path3.length - 1][0];
+    visit.parentCollection = (cst, path6) => {
+      const parent = visit.itemAtPath(cst, path6.slice(0, -1));
+      const field = path6[path6.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path3, item, visitor) {
-      let ctrl = visitor(item, path3);
+    function _visit(path6, item, visitor) {
+      let ctrl = visitor(item, path6);
       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(path3.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path6.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5583,10 +5604,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path3);
+            ctrl = ctrl(item, path6);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path3) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path6) : ctrl;
     }
     exports.visit = visit;
   }
@@ -5896,7 +5917,7 @@ var require_lexer = __commonJS({
           const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
           this.indentNext = this.indentValue + 1;
           this.indentValue += n;
-          return yield* this.parseBlockStart();
+          return "block-start";
         }
         return "doc";
       }
@@ -6195,28 +6216,38 @@ var require_lexer = __commonJS({
         return 0;
       }
       *pushIndicators() {
-        switch (this.charAt(0)) {
-          case "!":
-            return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-          case "&":
-            return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
-          case "-":
-          // this is an error
-          case "?":
-          // this is an error outside flow collections
-          case ":": {
-            const inFlow = this.flowLevel > 0;
-            const ch1 = this.charAt(1);
-            if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
-              if (!inFlow)
-                this.indentNext = this.indentValue + 1;
-              else if (this.flowKey)
-                this.flowKey = false;
-              return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+        let n = 0;
+        loop: while (true) {
+          switch (this.charAt(0)) {
+            case "!":
+              n += yield* this.pushTag();
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "&":
+              n += yield* this.pushUntil(isNotAnchorChar);
+              n += yield* this.pushSpaces(true);
+              continue loop;
+            case "-":
+            // this is an error
+            case "?":
+            // this is an error outside flow collections
+            case ":": {
+              const inFlow = this.flowLevel > 0;
+              const ch1 = this.charAt(1);
+              if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
+                if (!inFlow)
+                  this.indentNext = this.indentValue + 1;
+                else if (this.flowKey)
+                  this.flowKey = false;
+                n += yield* this.pushCount(1);
+                n += yield* this.pushSpaces(true);
+                continue loop;
+              }
             }
           }
+          break loop;
         }
-        return 0;
+        return n;
       }
       *pushTag() {
         if (this.charAt(1) === "<") {
@@ -6375,6 +6406,13 @@ var require_parser = __commonJS({
       }
       return prev.splice(i, prev.length);
     }
+    function arrayPushArray(target, source) {
+      if (source.length < 1e5)
+        Array.prototype.push.apply(target, source);
+      else
+        for (let i = 0; i < source.length; ++i)
+          target.push(source[i]);
+    }
     function fixFlowSeqItems(fc) {
       if (fc.start.type === "flow-seq-start") {
         for (const it of fc.items) {
@@ -6384,11 +6422,11 @@ var require_parser = __commonJS({
             delete it.key;
             if (isFlowToken(it.value)) {
               if (it.value.end)
-                Array.prototype.push.apply(it.value.end, it.sep);
+                arrayPushArray(it.value.end, it.sep);
               else
                 it.value.end = it.sep;
             } else
-              Array.prototype.push.apply(it.start, it.sep);
+              arrayPushArray(it.start, it.sep);
             delete it.sep;
           }
         }
@@ -6743,7 +6781,7 @@ var require_parser = __commonJS({
                 const prev = map.items[map.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  Array.prototype.push.apply(end, it.start);
+                  arrayPushArray(end, it.start);
                   end.push(this.sourceToken);
                   map.items.pop();
                   return;
@@ -6871,14 +6909,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs3 = this.flowScalar(this.type);
+              const fs6 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs3, sep: [] });
+                map.items.push({ start, key: fs6, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs3);
+                this.stack.push(fs6);
               } else {
-                Object.assign(it, { key: fs3, sep: [] });
+                Object.assign(it, { key: fs6, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -6931,7 +6969,7 @@ var require_parser = __commonJS({
                 const prev = seq.items[seq.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  Array.prototype.push.apply(end, it.start);
+                  arrayPushArray(end, it.start);
                   end.push(this.sourceToken);
                   seq.items.pop();
                   return;
@@ -7006,13 +7044,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs3 = this.flowScalar(this.type);
+              const fs6 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs3, sep: [] });
+                fc.items.push({ start: [], key: fs6, sep: [] });
               else if (it.sep)
-                this.stack.push(fs3);
+                this.stack.push(fs6);
               else
-                Object.assign(it, { key: fs3, sep: [] });
+                Object.assign(it, { key: fs6, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -7550,17 +7588,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path3, originalPath, doThrow) => {
-      if (!isString(path3)) {
+    var checkPath = (path6, originalPath, doThrow) => {
+      if (!isString(path6)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path3) {
+      if (!path6) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path3)) {
+      if (checkPath.isNotRelative(path6)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -7569,7 +7607,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path3) => REGEX_TEST_INVALID_PATH.test(path3);
+    var isNotRelative = (path6) => REGEX_TEST_INVALID_PATH.test(path6);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7628,7 +7666,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path3, checkUnignored) {
+      _testOne(path6, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -7636,7 +7674,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path3);
+          const matched = rule.regex.test(path6);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7649,24 +7687,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path3 = originalPath && checkPath.convert(originalPath);
+        const path6 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path3,
+          path6,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path3, cache, checkUnignored, slices);
+        return this._t(path6, cache, checkUnignored, slices);
       }
-      _t(path3, cache, checkUnignored, slices) {
-        if (path3 in cache) {
-          return cache[path3];
+      _t(path6, cache, checkUnignored, slices) {
+        if (path6 in cache) {
+          return cache[path6];
         }
         if (!slices) {
-          slices = path3.split(SLASH);
+          slices = path6.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path3] = this._testOne(path3, checkUnignored);
+          return cache[path6] = this._testOne(path6, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7674,24 +7712,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path3] = parent.ignored ? parent : this._testOne(path3, checkUnignored);
+        return cache[path6] = parent.ignored ? parent : this._testOne(path6, checkUnignored);
       }
-      ignores(path3) {
-        return this._test(path3, this._ignoreCache, false).ignored;
+      ignores(path6) {
+        return this._test(path6, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path3) => !this.ignores(path3);
+        return (path6) => !this.ignores(path6);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path3) {
-        return this._test(path3, this._testCache, true);
+      test(path6) {
+        return this._test(path6, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path3) => checkPath(path3 && checkPath.convert(path3), path3, RETURN_FALSE);
+    var isPathValid = (path6) => checkPath(path6 && checkPath.convert(path6), path6, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7702,38 +7740,626 @@ 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 = (path3) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path3) || isNotRelative(path3);
+      checkPath.isNotRelative = (path6) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path6) || isNotRelative(path6);
     }
   }
 });
 
 // src/index.js
-var import_yaml2 = __toESM(require_dist(), 1);
-var import_ignore2 = __toESM(require_ignore(), 1);
+var import_yaml3 = __toESM(require_dist(), 1);
+var import_ignore3 = __toESM(require_ignore(), 1);
 import crypto from "node:crypto";
-import fs2 from "node:fs";
+import fs5 from "node:fs";
 import http from "node:http";
 import os from "node:os";
-import path2 from "node:path";
-import { execFileSync } from "node:child_process";
+import path5 from "node:path";
 import { fileURLToPath } from "node:url";
 import { tool } from "@opencode-ai/plugin/tool";
 
-// src/validate_logic.js
-var import_yaml = __toESM(require_dist(), 1);
-var import_ignore = __toESM(require_ignore(), 1);
+// src/git_utils.js
 import fs from "node:fs";
 import path from "node:path";
+import { execFileSync } from "node:child_process";
+function toGitPath(worktree, targetPath) {
+  const relativePath = path.relative(worktree, targetPath);
+  if (!relativePath || relativePath.startsWith("..") || path.isAbsolute(relativePath)) return null;
+  return relativePath.split(path.sep).join("/");
+}
+function runGit(worktree, args) {
+  return execFileSync("git", args, {
+    cwd: worktree,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+}
+function sameFilesystemPath(left, right) {
+  try {
+    return fs.realpathSync(left) === fs.realpathSync(right);
+  } catch {
+    return path.resolve(left) === path.resolve(right);
+  }
+}
+function gitMigrationState(worktree) {
+  try {
+    const root = runGit(worktree, ["rev-parse", "--show-toplevel"]).trim();
+    if (!sameFilesystemPath(root, worktree)) return null;
+    return { worktree };
+  } catch {
+    return null;
+  }
+}
+function isGitTracked(gitState, targetPath) {
+  if (!gitState) return false;
+  const gitPath = toGitPath(gitState.worktree, targetPath);
+  if (!gitPath) return false;
+  try {
+    runGit(gitState.worktree, ["ls-files", "--error-unmatch", "--", gitPath]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasGitTrackedChildren(gitState, targetPath) {
+  if (!gitState) return false;
+  const gitPath = toGitPath(gitState.worktree, targetPath);
+  if (!gitPath) return false;
+  try {
+    return runGit(gitState.worktree, ["ls-files", "--", `${gitPath}/`]).trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function gitAwareMoveIfTracked(sourcePath, destinationPath, gitState) {
+  const sourceIsTracked = isGitTracked(gitState, sourcePath) || hasGitTrackedChildren(gitState, sourcePath);
+  if (!gitState || !sourceIsTracked || fs.existsSync(destinationPath)) return false;
+  const sourceGitPath = toGitPath(gitState.worktree, sourcePath);
+  const destinationGitPath = toGitPath(gitState.worktree, destinationPath);
+  if (!sourceGitPath || !destinationGitPath) return false;
+  fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+  try {
+    runGit(gitState.worktree, ["mv", "--", sourceGitPath, destinationGitPath]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function stageGitAwareMerge(sourcePath, destinationPath, gitState) {
+  if (!gitState) return;
+  const sourceGitPath = toGitPath(gitState.worktree, sourcePath);
+  const destinationGitPath = toGitPath(gitState.worktree, destinationPath);
+  if (!sourceGitPath || !destinationGitPath) return;
+  try {
+    runGit(gitState.worktree, ["add", "-A", "--", sourceGitPath, destinationGitPath]);
+  } catch {
+  }
+}
+
+// src/include_resolver.js
+import fs2 from "node:fs";
+import path2 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);
+}
+function resolveWithin(baseDir, relativePath) {
+  if (!relativePath) return null;
+  if (path2.isAbsolute(relativePath)) return null;
+  const resolved = path2.resolve(baseDir, relativePath);
+  return isSameOrNestedPath(resolved, baseDir) ? resolved : null;
+}
+function withCompactPreference(paths, options = {}) {
+  if (!options.preferCompactPromptDocs) return paths;
+  const compactPaths = paths.map((filePath) => filePath ? compactPromptPath(filePath) : null).filter(Boolean);
+  return [...compactPaths, ...paths];
+}
+function resolveIncludeFile(includeRef, repoRoot, bundleRoot, options = {}) {
+  const trimmed = String(includeRef || "").trim();
+  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");
+  if (scope === "plugin") {
+    for (const filePath of withCompactPreference([resolveWithin(bundleRoot, target)], options)) {
+      if (filePath && fs2.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;
+    }
+    return null;
+  }
+  if (scope === "policy") {
+    const candidates2 = withCompactPreference([
+      resolveWithin(repoPolicyRoot, target),
+      resolveWithin(bundlePolicyRoot, target)
+    ], options);
+    for (const filePath of candidates2) {
+      if (filePath && fs2.existsSync(filePath)) return filePath;
+    }
+    return null;
+  }
+  const candidates = withCompactPreference([
+    resolveWithin(repoRoot, target),
+    resolveWithin(bundleRoot, target)
+  ], options);
+  for (const filePath of candidates) {
+    if (filePath && fs2.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function resolveIncludes(text, repoRoot, bundleRoot, options = {}) {
+  const includeDepth = Number(options.includeDepth || 0);
+  const maxIncludeDepth = Number(options.maxIncludeDepth || 20);
+  if (includeDepth > maxIncludeDepth) {
+    return "\n\n# ERROR: Include recursion limit exceeded.\n\n";
+  }
+  const includeRegex = /<include:(.*?)>/g;
+  return String(text || "").replace(includeRegex, (match, includeRef) => {
+    const filePath = resolveIncludeFile(includeRef, repoRoot, bundleRoot, options);
+    if (!filePath) {
+      console.warn(`[Optima] Include file not found: ${includeRef}`);
+      return `
+
+# ERROR: Include file not found: ${includeRef}
+
+`;
+    }
+    const content = fs2.readFileSync(filePath, "utf8");
+    return resolveIncludes(content, repoRoot, bundleRoot, { ...options, includeDepth: includeDepth + 1, maxIncludeDepth });
+  });
+}
+
+// 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";
+var CODEMAP_SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".ts",
+  ".tsx",
+  ".jsx",
+  ".dart",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".c",
+  ".cpp",
+  ".cs",
+  ".php",
+  ".rb",
+  ".swift",
+  ".kt",
+  ".m",
+  ".sh",
+  ".sql",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".md"
+]);
+var LEGACY_OPERATIONAL_ROOTS = /* @__PURE__ */ new Set([
+  "tasks",
+  "evidences",
+  ".orbita",
+  ".staticeng",
+  ".nomadworks",
+  ".nomadwork",
+  "nomadworks",
+  ".codenomad"
+]);
+var OPTIMA_OPERATIONAL_FOLDERS = [".optima", "templates", "dist"];
+function relPath(worktree, targetPath) {
+  return path3.relative(worktree, targetPath).split(path3.sep).join("/") || ".";
+}
+function normalizeCodemapRelPath(relPathValue) {
+  return path3.normalize(relPathValue).replace(/\\/g, "/").replace(/\/$/, "");
+}
+function firstPathSegment(relPathValue) {
+  return normalizeCodemapRelPath(relPathValue).split("/").filter(Boolean)[0] || "";
+}
+function isOperationalRelPath(relPathValue) {
+  if (!relPathValue) return false;
+  const normalized = normalizeCodemapRelPath(relPathValue);
+  const firstSegment = firstPathSegment(normalized);
+  if (LEGACY_OPERATIONAL_ROOTS.has(firstSegment)) return true;
+  return OPTIMA_OPERATIONAL_FOLDERS.some((folder) => normalized === folder || normalized.startsWith(`${folder}/`));
+}
+function isHiddenTree(relPathValue) {
+  if (!relPathValue) return false;
+  return normalizeCodemapRelPath(relPathValue).split("/").some((part) => part.startsWith("."));
+}
+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"));
+  return ig;
+}
+function codemapSectionEntries(value) {
+  if (Array.isArray(value)) return value;
+  if (value && typeof value === "object") return Object.values(value);
+  return [];
+}
+function codemapIndexedPaths(map) {
+  const indexed = /* @__PURE__ */ new Set();
+  for (const section of ["modules", "entrypoints", "sources_of_truth", "links", "internals"]) {
+    for (const item of codemapSectionEntries(map?.[section])) {
+      if (item?.path) indexed.add(normalizeCodemapRelPath(item.path));
+    }
+  }
+  return indexed;
+}
+function readCodemap(filePath, unresolved, worktree) {
+  try {
+    const parsed = import_yaml.default.parse(fs3.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;
+    }
+    return parsed;
+  } catch {
+    unresolved.push({ category: "codemap", path: relPath(worktree, filePath), message: "CodeMap has invalid YAML; manual repair required." });
+    return null;
+  }
+}
+function writeCodemap(filePath, map) {
+  fs3.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 (isIgnoredPath(ig, relative) || isOperationalRelPath(relative)) continue;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path3.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 (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);
+    if (isIgnoredPath(ig, relative) || isOperationalRelPath(relative) || isHiddenTree(relative)) continue;
+    if (item.isFile() && CODEMAP_SOURCE_EXTENSIONS.has(path3.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 entrypoints = [];
+  const internals = [];
+  const relToRoot = path3.relative(dirPath, deps.optimaCodemapPath(worktree)).split(path3.sep).join("/");
+  for (const item of entries) {
+    if (!item.isFile() || item.name === "codemap.yml" || !CODEMAP_SOURCE_EXTENSIONS.has(path3.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 });
+  }
+  const map = { scope: "module", parent: relToRoot };
+  if (entrypoints.length > 0) map.entrypoints = entrypoints;
+  map.internals = internals;
+  return map;
+}
+function repairSingleCodemap(codemapPath, worktree, apply, registerAction, unresolved, deps) {
+  const map = readCodemap(codemapPath, unresolved, worktree);
+  if (!map) return;
+  const isRootMap = codemapPath === deps.optimaCodemapPath(worktree);
+  const mapDir = path3.dirname(codemapPath);
+  const pathBase = isRootMap ? worktree : mapDir;
+  let changed = false;
+  for (const section of ["modules", "entrypoints", "sources_of_truth", "links", "internals"]) {
+    const originalEntries = codemapSectionEntries(map[section]);
+    if (!Array.isArray(map[section]) && originalEntries.length > 0) {
+      unresolved.push({ category: "codemap", path: relPath(worktree, codemapPath), message: `Section '${section}' is object-shaped; repair leaves it unchanged to avoid changing user structure.` });
+      continue;
+    }
+    const nextEntries = [];
+    for (const entry of originalEntries) {
+      if (!entry?.path || entry.path.startsWith("http://") || entry.path.startsWith("https://") || path3.isAbsolute(entry.path)) {
+        nextEntries.push(entry);
+        continue;
+      }
+      const normalizedPath = normalizeCodemapRelPath(entry.path);
+      const absPath = path3.join(pathBase, normalizedPath);
+      if (!fs3.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;
+      }
+      const parts = normalizedPath.split("/").filter((part) => part && part !== ".");
+      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)) {
+          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}'.` });
+          continue;
+        }
+        unresolved.push({ category: "codemap", path: relPath(worktree, codemapPath), message: `Path '${entry.path}' violates Rule of Local Knowledge and no safe local replacement exists.` });
+        nextEntries.push(entry);
+        continue;
+      }
+      nextEntries.push(entry);
+    }
+    if (Array.isArray(map[section])) map[section] = nextEntries;
+  }
+  if (map.scope === "module" && !isOperationalRelPath(path3.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;
+      if (indexed.has(item.name)) continue;
+      internals.push({ path: item.name });
+      indexed.add(item.name);
+      changed = true;
+      registerAction({ category: "codemap", action: apply ? "updated" : "would_update", path: relPath(worktree, codemapPath), detail: `Categorize immediate source file '${item.name}' as internal.` });
+    }
+    if (internals.length > 0) map.internals = internals;
+  }
+  if (changed && apply) writeCodemap(codemapPath, map);
+}
+function repairCodemaps(worktree, apply, actions, unresolved, deps) {
+  const ig = loadGitIgnoreMatcher(worktree);
+  const rootCodemapPath = deps.optimaCodemapPath(worktree);
+  const rootCodemapMissing = !fs3.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;
+  let rootChanged = false;
+  const rootModulesRepairable = rootMap && (rootMap.modules === void 0 || Array.isArray(rootMap.modules));
+  if (rootMap) {
+    rootMap.scope ||= "repo";
+    if (rootModulesRepairable) {
+      rootMap.modules = Array.isArray(rootMap.modules) ? rootMap.modules : [];
+    } else {
+      unresolved.push({ category: "codemap", path: ".optima/codemap.yml", message: "Root modules section is object-shaped; repair will not add module entries to avoid changing user structure." });
+    }
+  }
+  function walk(dirPath) {
+    const relative = path3.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 sourceDir = relative && containsSource(dirPath, ig, worktree);
+    if (sourceDir && !hasCodemap && dirPath !== worktree) {
+      if (hasImmediateSourceFile(dirPath, ig, worktree)) {
+        actions.push({ category: "codemap", action: apply ? "created" : "would_create", path: relPath(worktree, codemapPath), detail: "Create missing module CodeMap for source directory." });
+        if (apply) writeCodemap(codemapPath, createModuleCodemap(dirPath, worktree, deps));
+      } else {
+        unresolved.push({ category: "codemap", path: relPath(worktree, dirPath), message: "Directory contains source only in nested directories; create a local CodeMap after deciding module boundaries." });
+      }
+    }
+    if (rootMap && rootModulesRepairable && relative && sourceDir && normalizeCodemapRelPath(relative).split("/").length === 1) {
+      const modules = codemapSectionEntries(rootMap.modules);
+      if (!modules.some((entry) => normalizeCodemapRelPath(entry.path) === normalizeCodemapRelPath(relative))) {
+        rootMap.modules = modules;
+        rootMap.modules.push({ path: normalizeCodemapRelPath(relative), summary: "Maintained source module." });
+        rootChanged = true;
+        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 (fs3.existsSync(worktree)) walk(worktree);
+  if (rootMap && rootChanged && apply) writeCodemap(rootCodemapPath, rootMap);
+}
+function walkMarkdownFiles(dirPath) {
+  if (!fs3.existsSync(dirPath)) return [];
+  const files = [];
+  for (const entry of fs3.readdirSync(dirPath, { withFileTypes: true })) {
+    const entryPath = path3.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...walkMarkdownFiles(entryPath));
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+function isMarkdownReferenceNormalizationExempt(line) {
+  const normalized = line.toLowerCase().replace(/[`*_~]/g, "");
+  const pathToken = "(?:tasks/|evidences/|docs/scrs/|codemap\\.yml|logs/|screenshots/)";
+  if (new RegExp(`\\b(root|legacy)\\s+${pathToken}`).test(normalized)) return true;
+  if (new RegExp(`\\b(do not|don't|never|must not|should not|avoid|forbid|prohibit)\\b[^\\n]*${pathToken}`).test(normalized)) return true;
+  if (/\b(historical|problem|prohibition)\b[^\n]*(tasks\/|evidences\/|docs\/scrs\/|codemap\.yml|logs\/|screenshots\/)/.test(normalized)) return true;
+  return false;
+}
+function rewriteReferenceToken(text, fromPrefix, toPrefix) {
+  const escapedPrefix = fromPrefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp("(^|[\\s([{\"'<`])" + escapedPrefix + `(?=[^\\s)\\]}>"']+)`, "g");
+  return text.replace(pattern, `$1${toPrefix}`);
+}
+function rewriteOptimaMarkdownReferences(content, evidenceBasePath = null) {
+  return content.split(/(\r?\n)/).map((part) => {
+    if (part === "\n" || part === "\r\n" || isMarkdownReferenceNormalizationExempt(part)) return part;
+    let next = part;
+    next = rewriteReferenceToken(next, "tasks/", ".optima/tasks/");
+    next = rewriteReferenceToken(next, "evidences/", ".optima/evidences/");
+    next = rewriteReferenceToken(next, "docs/scrs/", ".optima/docs/scrs/");
+    next = next.replace(/(^|[\s([{"'<`])codemap\.yml\b/g, "$1.optima/codemap.yml");
+    if (evidenceBasePath) {
+      next = rewriteReferenceToken(next, "logs/", `${evidenceBasePath}/logs/`);
+      next = rewriteReferenceToken(next, "screenshots/", `${evidenceBasePath}/screenshots/`);
+    }
+    return next;
+  }).join("");
+}
+function optimaEvidenceBaseForFile(worktree, filePath, deps) {
+  const evidenceRoot = deps.optimaEvidencesDir(worktree);
+  const relative = path3.relative(evidenceRoot, filePath).split(path3.sep).join("/");
+  const [taskId] = relative.split("/");
+  if (!taskId || taskId === ".." || relative.startsWith("../")) return null;
+  return `.optima/evidences/${taskId}`;
+}
+function normalizeOptimaMarkdownReferences(worktree, deps) {
+  const scanRoots = [
+    deps.optimaTasksDir(worktree),
+    deps.optimaEvidencesDir(worktree),
+    deps.optimaScrsDir(worktree)
+  ];
+  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 rewritten = rewriteOptimaMarkdownReferences(raw, evidenceBasePath);
+    if (rewritten !== raw) {
+      fs3.writeFileSync(filePath, rewritten, "utf8");
+      changed.push(relPath(worktree, filePath));
+    }
+  }
+  return changed;
+}
+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 existingRules = new Set(existing.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+  return deps.optimaGitignoreRules.filter((rule) => !existingRules.has(rule));
+}
+function repairMode(args = {}) {
+  const value = args.apply ?? args.mode;
+  if (value === true || value === "apply") return "apply";
+  return "dry-run";
+}
+function pushRepairAction(actions, category, action, pathValue, detail) {
+  actions.push({ category, action, path: pathValue, detail });
+}
+function planOptimaRepair(worktree, args = {}, deps) {
+  const mode = repairMode(args);
+  const apply = mode === "apply";
+  const actions = [];
+  const unresolved = [];
+  const hadOptima = fs3.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;
+    return rewriteOptimaMarkdownReferences(raw, evidenceBasePath) !== raw;
+  }).map((filePath) => relPath(worktree, filePath));
+  if (!hadOptima) pushRepairAction(actions, "operational", apply ? "created" : "would_create", ".optima/", "Create Optima operational root.");
+  const legacySources = [
+    [".orbita/", deps.legacyOrbitaDir(worktree)],
+    [".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")]
+  ];
+  if (!deps.isOptimaPluginPackageWorktree(worktree)) legacySources.push(["policies/", path3.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 (apply) deps.migrateLegacyOptimaLayout(worktree);
+  const configMissing = !fs3.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]
+  ];
+  for (const [filePath, category, displayPath, content] of requiredFiles) {
+    if (!fs3.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);
+    }
+  }
+  if (apply) {
+    deps.scaffoldOptimaReadmes(worktree);
+    deps.ensureOptimaRegistries(worktree);
+    normalizeOptimaMarkdownReferences(worktree, deps).forEach((filePath) => {
+      pushRepairAction(actions, "markdown", "normalized", filePath, "Normalize Optima artifact paths in Markdown.");
+    });
+  } else {
+    markdownBefore.forEach((filePath) => pushRepairAction(actions, "markdown", "would_normalize", filePath, "Normalize Optima artifact paths in Markdown."));
+  }
+  if (missingGitignoreRules.length > 0) {
+    pushRepairAction(actions, "gitignore", apply ? "updated" : "would_update", ".gitignore", `Add ${missingGitignoreRules.length} Optima local/private rule(s).`);
+    if (apply) deps.ensureOptimaGitignoreRules(worktree);
+  }
+  repairCodemaps(worktree, apply, actions, unresolved, deps);
+  return { mode, actions, unresolved };
+}
+function formatRepairResult(plan, validationResult = null, formatValidationResult2 = (res) => JSON.stringify(res, null, 2)) {
+  const lines = [
+    `Optima repair ${plan.mode === "apply" ? "applied" : "dry-run"}.`,
+    "Scope inspected: config, registries, templates, policy scaffolding, legacy/root artifact leakage, Markdown path normalization, gitignore rules, and CodeMap integrity.",
+    "",
+    "Planned/Applied fixes:"
+  ];
+  if (plan.actions.length === 0) {
+    lines.push("- None");
+  } else {
+    for (const action of plan.actions) {
+      lines.push(`- [${action.category}] ${action.action} ${action.path}: ${action.detail}`);
+    }
+  }
+  lines.push("", "Unresolved issues:");
+  if (plan.unresolved.length === 0) {
+    lines.push("- None");
+  } else {
+    for (const issue of plan.unresolved) {
+      lines.push(`- [${issue.category}] ${issue.path}: ${issue.message}`);
+    }
+  }
+  if (validationResult) {
+    lines.push("", "Validation after apply:", formatValidationResult2(validationResult));
+  } else {
+    lines.push("", "Validation after apply: not run in dry-run mode.");
+  }
+  return lines.join("\n");
+}
+
+// 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";
 async function optima_validate_logic(worktree) {
-  const rootCodemapPath = path.join(worktree, ".optima", "codemap.yml");
-  if (!fs.existsSync(rootCodemapPath)) return { ok: false, errors: [".optima/codemap.yml not found."], warnings: [] };
+  const rootCodemapPath = path4.join(worktree, ".optima", "codemap.yml");
+  if (!fs4.existsSync(rootCodemapPath)) return { ok: false, errors: [".optima/codemap.yml not found."], warnings: [] };
   const errors = [];
   const warnings = [];
-  const ig = (0, import_ignore.default)();
+  const ig = (0, import_ignore2.default)();
   ig.add(".git");
-  const gitignorePath = path.join(worktree, ".gitignore");
-  if (fs.existsSync(gitignorePath)) {
-    ig.add(fs.readFileSync(gitignorePath, "utf8"));
+  const gitignorePath = path4.join(worktree, ".gitignore");
+  if (fs4.existsSync(gitignorePath)) {
+    ig.add(fs4.readFileSync(gitignorePath, "utf8"));
   }
   const sourceExtensions = [
     ".js",
@@ -7771,32 +8397,32 @@ async function optima_validate_logic(worktree) {
     ".codenomad"
   ]);
   const operationalFolders = [".optima", "templates", "dist"];
-  const isHiddenTree = (relPath) => {
-    if (!relPath) return false;
-    return relPath.split(path.sep).some((part) => part.startsWith("."));
+  const isHiddenTree2 = (relPath2) => {
+    if (!relPath2) return false;
+    return relPath2.split(path4.sep).some((part) => part.startsWith("."));
   };
-  const firstPathSegment = (relPath) => relPath.split(path.sep).filter(Boolean)[0] || "";
-  const isOperationalRelPath = (relPath) => {
-    if (!relPath) return false;
-    const firstSegment = firstPathSegment(relPath);
+  const firstPathSegment2 = (relPath2) => relPath2.split(path4.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) => relPath === f || relPath.startsWith(f + path.sep));
+    return operationalFolders.some((f) => relPath2 === f || relPath2.startsWith(f + path4.sep));
   };
   const getSectionEntries = (value) => {
     if (Array.isArray(value)) return value;
     if (value && typeof value === "object") return Object.values(value);
     return [];
   };
-  const normalizeRelativePath = (relPath) => path.normalize(relPath).replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizeRelativePath = (relPath2) => path4.normalize(relPath2).replace(/\\/g, "/").replace(/\/$/, "");
   const isSourceDir = (dirPath) => {
-    const dirRelPath = path.relative(worktree, dirPath);
-    if (isOperationalRelPath(dirRelPath)) return false;
-    const items = fs.readdirSync(dirPath, { withFileTypes: true });
+    const dirRelPath = path4.relative(worktree, dirPath);
+    if (isOperationalRelPath2(dirRelPath)) return false;
+    const items = fs4.readdirSync(dirPath, { withFileTypes: true });
     for (const item of items) {
-      const childPath = path.join(dirPath, item.name);
-      const relPath = path.relative(worktree, childPath);
-      if (ig.ignores(relPath) || isOperationalRelPath(relPath)) continue;
-      if (item.isFile() && sourceExtensions.includes(path.extname(item.name))) return true;
+      const childPath = path4.join(dirPath, item.name);
+      const relPath2 = path4.relative(worktree, childPath);
+      if (ig.ignores(relPath2) || isOperationalRelPath2(relPath2)) continue;
+      if (item.isFile() && sourceExtensions.includes(path4.extname(item.name))) return true;
       if (item.isDirectory()) {
         if (isSourceDir(childPath)) return true;
       }
@@ -7804,10 +8430,10 @@ async function optima_validate_logic(worktree) {
     return false;
   };
   function validateMap(filePath) {
-    const content = fs.readFileSync(filePath, "utf8");
+    const content = fs4.readFileSync(filePath, "utf8");
     let map;
     try {
-      map = import_yaml.default.parse(content);
+      map = import_yaml2.default.parse(content);
       if (!map || typeof map !== "object") {
         errors.push(`${filePath}: CodeMap is empty or invalid.`);
         return;
@@ -7816,32 +8442,32 @@ async function optima_validate_logic(worktree) {
       errors.push(`${filePath}: Invalid YAML.`);
       return;
     }
-    const dir = path.dirname(filePath);
+    const dir = path4.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(path.normalize(item.path));
+          indexedPaths.add(path4.normalize(item.path));
           if (section === "links" && (item.path.startsWith("http://") || item.path.startsWith("https://"))) {
             continue;
           }
-          const absPath = path.isAbsolute(item.path) ? item.path : path.join(pathBase, item.path);
-          if (!fs.existsSync(absPath)) {
+          const absPath = path4.isAbsolute(item.path) ? item.path : path4.join(pathBase, item.path);
+          if (!fs4.existsSync(absPath)) {
             errors.push(`${filePath}: ${section.slice(0, -1)} path does not exist: ${item.path}`);
           }
         }
       }
     }
-    const relDir = path.relative(worktree, dir);
-    const isOperational = isOperationalRelPath(relDir);
+    const relDir = path4.relative(worktree, dir);
+    const isOperational = isOperationalRelPath2(relDir);
     if (map.scope === "module" && !isOperational) {
-      const items = fs.readdirSync(dir, { withFileTypes: true });
+      const items = fs4.readdirSync(dir, { withFileTypes: true });
       for (const item of items) {
-        if (item.isFile() && sourceExtensions.includes(path.extname(item.name))) {
+        if (item.isFile() && sourceExtensions.includes(path4.extname(item.name))) {
           if (item.name === "codemap.yml") continue;
-          if (!indexedPaths.has(path.normalize(item.name))) {
+          if (!indexedPaths.has(path4.normalize(item.name))) {
             errors.push(`${filePath}: Unindexed source file found: '${item.name}'. Every source file must be categorized in a section (e.g., 'internals').`);
           }
         }
@@ -7851,7 +8477,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 (path.isAbsolute(entry.path)) continue;
+        if (path4.isAbsolute(entry.path)) continue;
         const normalizedPath = normalizeRelativePath(entry.path);
         if (!normalizedPath || normalizedPath === ".") continue;
         const parts = normalizedPath.split("/").filter((p) => p && p !== ".");
@@ -7863,30 +8489,30 @@ async function optima_validate_logic(worktree) {
     }
   }
   const walk = (dir) => {
-    const relDir = path.relative(worktree, dir);
+    const relDir = path4.relative(worktree, dir);
     if (relDir && ig.ignores(relDir)) return;
-    if (isOperationalRelPath(relDir)) return;
-    if (isHiddenTree(relDir)) return;
-    const hasCodemap = fs.existsSync(path.join(dir, "codemap.yml"));
-    const items = fs.readdirSync(dir, { withFileTypes: true });
-    if (!relDir.startsWith(path.join(".optima", "tasks", "done"))) {
+    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"))) {
       for (const item of items) {
         if (item.isFile() && item.name.endsWith(".md")) {
-          const content = fs.readFileSync(path.join(dir, item.name), "utf8");
+          const content = fs4.readFileSync(path4.join(dir, item.name), "utf8");
           if (content.includes("[To be defined]") || content.includes("[Insert ")) {
-            const relFilePath = path.join(relDir, item.name);
+            const relFilePath = path4.join(relDir, item.name);
             errors.push(`Documentation Placeholder found: '${relFilePath}' still contains [To be defined] or [Insert ...] placeholders.`);
           }
         }
       }
     }
-    const isOperational = isOperationalRelPath(relDir);
+    const isOperational = isOperationalRelPath2(relDir);
     if (relDir !== "" && !hasCodemap && isSourceDir(dir) && !isOperational) {
       errors.push(`Missing CodeMap: Directory '${relDir}' contains source but has no codemap.yml.`);
     }
-    if (hasCodemap) validateMap(path.join(dir, "codemap.yml"));
+    if (hasCodemap) validateMap(path4.join(dir, "codemap.yml"));
     for (const item of items) {
-      if (item.isDirectory()) walk(path.join(dir, item.name));
+      if (item.isDirectory()) walk(path4.join(dir, item.name));
     }
   };
   validateMap(rootCodemapPath);
@@ -7899,12 +8525,12 @@ async function optima_validate_logic(worktree) {
 }
 
 // src/index.js
-var PKG_ROOT = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)), "..");
-var BUNDLE_ASSETS_DIR = path2.join(PKG_ROOT, "assets");
-var BUNDLE_AGENTS_DIR = path2.join(BUNDLE_ASSETS_DIR, "agents");
-var BUNDLE_POLICIES_DIR = path2.join(BUNDLE_ASSETS_DIR, "policies");
-var TEMPLATES_DIR = path2.join(PKG_ROOT, "templates");
-var HUMANS_REGISTRY_PATH = path2.join(PKG_ROOT, "docs", "core", "humans.md");
+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 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"];
@@ -8040,18 +8666,18 @@ function objectIdentity(value) {
   return objectIdentityMap.get(value);
 }
 function isRootDirectory(candidate) {
-  const resolved = path2.resolve(candidate);
-  return resolved === path2.parse(resolved).root;
+  const resolved = path5.resolve(candidate);
+  return resolved === path5.parse(resolved).root;
 }
 function isSafeWritableDirectory(candidate) {
   if (typeof candidate !== "string" || !candidate.trim()) return false;
-  if (!path2.isAbsolute(candidate)) return false;
-  const resolved = path2.resolve(candidate);
+  if (!path5.isAbsolute(candidate)) return false;
+  const resolved = path5.resolve(candidate);
   if (isRootDirectory(resolved)) return false;
   try {
-    const stat = fs2.statSync(resolved);
+    const stat = fs5.statSync(resolved);
     if (!stat.isDirectory()) return false;
-    fs2.accessSync(resolved, fs2.constants.W_OK);
+    fs5.accessSync(resolved, fs5.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -8067,7 +8693,7 @@ function resolveSafeWorktree(context = {}, pluginWorktree = null) {
   ];
   for (const candidate of candidates) {
     if (typeof candidate !== "string" || !candidate.trim()) continue;
-    const resolved = path2.resolve(candidate);
+    const resolved = path5.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   throw new Error(SAFE_WORKTREE_FAILURE);
@@ -8082,13 +8708,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 = path2.resolve(candidate);
+    const resolved = path5.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   return null;
 }
 function isGitRepository(worktree) {
-  return fs2.existsSync(path2.join(worktree, ".git"));
+  return fs5.existsSync(path5.join(worktree, ".git"));
 }
 function normalizeLooseToken(value) {
   return String(value ?? "").trim().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -8122,8 +8748,8 @@ function parseHumansRegistry(markdown = "") {
   return roles;
 }
 function loadHumansRegistry(registryPath = HUMANS_REGISTRY_PATH) {
-  if (!fs2.existsSync(registryPath)) return {};
-  return parseHumansRegistry(fs2.readFileSync(registryPath, "utf8"));
+  if (!fs5.existsSync(registryPath)) return {};
+  return parseHumansRegistry(fs5.readFileSync(registryPath, "utf8"));
 }
 function resolveHumanRoles(roles = CLICKUP_FINAL_APPROVER_ROLES, registry = loadHumansRegistry()) {
   return [...new Set(roles.map((role) => registry[String(role ?? "").trim()] || "").filter(Boolean))];
@@ -8290,7 +8916,7 @@ function parseMarkdownArtifact(markdown = "", { requiredSections = [] } = {}) {
   };
 }
 function readMarkdownArtifact(filePath, options = {}) {
-  const markdown = fs2.readFileSync(filePath, "utf8");
+  const markdown = fs5.readFileSync(filePath, "utf8");
   return parseMarkdownArtifact(markdown, options);
 }
 function stripRawLogSections(sections = {}) {
@@ -8576,7 +9202,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 path2.join(path2.dirname(root), `${path2.basename(root)}-${branch.replace(/\//g, "-")}`);
+  return path5.join(path5.dirname(root), `${path5.basename(root)}-${branch.replace(/\//g, "-")}`);
 }
 function clickUpCustomFieldValue(task = {}, names = []) {
   const fields = Array.isArray(task.custom_fields) ? task.custom_fields : [];
@@ -8600,12 +9226,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 || !path2.isAbsolute(existingWorktree) || !fs2.existsSync(existingWorktree)) return null;
+  if (!existingWorktree || !path5.isAbsolute(existingWorktree) || !fs5.existsSync(existingWorktree)) return null;
   try {
-    const stat = fs2.statSync(existingWorktree);
+    const stat = fs5.statSync(existingWorktree);
     if (!stat.isDirectory()) return null;
     if (branch && existingBranch && existingBranch !== branch) return null;
-    return { branch: existingBranch || branch, worktree: path2.resolve(existingWorktree), reused: true };
+    return { branch: existingBranch || branch, worktree: path5.resolve(existingWorktree), reused: true };
   } catch {
     return null;
   }
@@ -8616,10 +9242,10 @@ function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tare
   const existing = safeExistingClickUpWorktree({ metadata: existingMetadata, branch });
   if (existing) return { ...existing, branch };
   const worktreePath = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
-  if (fs2.existsSync(worktreePath)) return { branch, worktree: path2.resolve(worktreePath), reused: true };
+  if (fs5.existsSync(worktreePath)) return { branch, worktree: path5.resolve(worktreePath), reused: true };
   if (allowNonGitFallback) {
-    fs2.mkdirSync(worktreePath, { recursive: true });
-    return { branch, worktree: path2.resolve(worktreePath), reused: false, fallback: "non_git" };
+    fs5.mkdirSync(worktreePath, { recursive: true });
+    return { branch, worktree: path5.resolve(worktreePath), reused: false, fallback: "non_git" };
   }
   const startPoint = (() => {
     try {
@@ -8630,7 +9256,7 @@ function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tare
     }
   })();
   runGitFn(baseWorktree, ["worktree", "add", "-b", branch, worktreePath, startPoint]);
-  return { branch, worktree: path2.resolve(worktreePath), reused: false, startPoint };
+  return { branch, worktree: path5.resolve(worktreePath), reused: false, startPoint };
 }
 function normalizeClickUpDefinitionDocParent(parent = {}) {
   const docId = String(parent.doc_id || parent.docId || CLICKUP_DEFINITION_DOC_PARENT.doc_id).trim();
@@ -8765,76 +9391,10 @@ function buildClickUpTransitionPayload({ fromStatus, toStatus, validationPassed
     }
   };
 }
-function toGitPath(worktree, targetPath) {
-  const relativePath = path2.relative(worktree, targetPath);
-  if (!relativePath || relativePath.startsWith("..") || path2.isAbsolute(relativePath)) return null;
-  return relativePath.split(path2.sep).join("/");
-}
-function runGit(worktree, args) {
-  return execFileSync("git", args, {
-    cwd: worktree,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-}
-function gitMigrationState(worktree) {
-  try {
-    const root = runGit(worktree, ["rev-parse", "--show-toplevel"]).trim();
-    if (path2.resolve(root) !== path2.resolve(worktree)) return null;
-    return { worktree };
-  } catch {
-    return null;
-  }
-}
-function isGitTracked(gitState, targetPath) {
-  if (!gitState) return false;
-  const gitPath = toGitPath(gitState.worktree, targetPath);
-  if (!gitPath) return false;
-  try {
-    runGit(gitState.worktree, ["ls-files", "--error-unmatch", "--", gitPath]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function hasGitTrackedChildren(gitState, targetPath) {
-  if (!gitState) return false;
-  const gitPath = toGitPath(gitState.worktree, targetPath);
-  if (!gitPath) return false;
-  try {
-    return runGit(gitState.worktree, ["ls-files", "--", `${gitPath}/`]).trim().length > 0;
-  } catch {
-    return false;
-  }
-}
-function gitAwareMoveIfTracked(sourcePath, destinationPath, gitState) {
-  const sourceIsTracked = isGitTracked(gitState, sourcePath) || hasGitTrackedChildren(gitState, sourcePath);
-  if (!gitState || !sourceIsTracked || fs2.existsSync(destinationPath)) return false;
-  const sourceGitPath = toGitPath(gitState.worktree, sourcePath);
-  const destinationGitPath = toGitPath(gitState.worktree, destinationPath);
-  if (!sourceGitPath || !destinationGitPath) return false;
-  fs2.mkdirSync(path2.dirname(destinationPath), { recursive: true });
-  try {
-    runGit(gitState.worktree, ["mv", "--", sourceGitPath, destinationGitPath]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function stageGitAwareMerge(sourcePath, destinationPath, gitState) {
-  if (!gitState || !isGitTracked(gitState, sourcePath)) return;
-  const sourceGitPath = toGitPath(gitState.worktree, sourcePath);
-  const destinationGitPath = toGitPath(gitState.worktree, destinationPath);
-  if (!sourceGitPath || !destinationGitPath) return;
-  try {
-    runGit(gitState.worktree, ["add", "-A", "--", sourceGitPath, destinationGitPath]);
-  } catch {
-  }
-}
 function ensureOptimaGitignoreRules(worktree) {
   if (!isGitRepository(worktree)) return { touched: false, added: [] };
-  const gitignorePath = path2.join(worktree, ".gitignore");
-  const existing = fs2.existsSync(gitignorePath) ? fs2.readFileSync(gitignorePath, "utf8") : "";
+  const gitignorePath = path5.join(worktree, ".gitignore");
+  const existing = fs5.existsSync(gitignorePath) ? fs5.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: [] };
@@ -8844,49 +9404,45 @@ function ensureOptimaGitignoreRules(worktree) {
     "# Optima local/private state",
     ...missingRules
   ].join("\n");
-  fs2.writeFileSync(gitignorePath, `${existing}${prefix}${separator}${block}
+  fs5.writeFileSync(gitignorePath, `${existing}${prefix}${separator}${block}
 `, "utf8");
   return { touched: true, added: missingRules };
 }
-function compactPromptPath(filePath) {
-  if (!filePath.endsWith(".md") || filePath.endsWith(".prompt.md")) return null;
-  return filePath.replace(/\.md$/, ".prompt.md");
-}
 function optimaDir(worktree) {
-  return path2.join(worktree, OPTIMA_DIRNAME);
+  return path5.join(worktree, OPTIMA_DIRNAME);
 }
 function optimaLocalConfigDir(worktree) {
-  return path2.join(optimaDir(worktree), ".config");
+  return path5.join(optimaDir(worktree), ".config");
 }
 function optimaConfigDir(worktree) {
   return optimaLocalConfigDir(worktree);
 }
 function optimaCodemapPath(worktree) {
-  return path2.join(optimaDir(worktree), "codemap.yml");
+  return path5.join(optimaDir(worktree), "codemap.yml");
 }
 function optimaTasksDir(worktree) {
-  return path2.join(optimaDir(worktree), "tasks");
+  return path5.join(optimaDir(worktree), "tasks");
 }
 function optimaEvidencesDir(worktree) {
-  return path2.join(optimaDir(worktree), "evidences");
+  return path5.join(optimaDir(worktree), "evidences");
 }
 function optimaScrsDir(worktree) {
-  return path2.join(optimaDir(worktree), "docs", "scrs");
+  return path5.join(optimaDir(worktree), "docs", "scrs");
 }
 function legacyNomadworkDir(worktree) {
-  return path2.join(worktree, LEGACY_NOMADWORK_DIRNAME);
+  return path5.join(worktree, LEGACY_NOMADWORK_DIRNAME);
 }
 function legacyNomadworksDir(worktree) {
-  return path2.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
+  return path5.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
 }
 function legacyOrbitaDir(worktree) {
-  return path2.join(worktree, LEGACY_ORBITA_DIRNAME);
+  return path5.join(worktree, LEGACY_ORBITA_DIRNAME);
 }
 function legacyStaticEngDir(worktree) {
-  return path2.join(worktree, LEGACY_STATICENG_DIRNAME);
+  return path5.join(worktree, LEGACY_STATICENG_DIRNAME);
 }
 function repoConfigPath(worktree) {
-  return path2.join(optimaConfigDir(worktree), "optima.yaml");
+  return path5.join(optimaConfigDir(worktree), "optima.yaml");
 }
 function normalizeLegacyDiscussionEntry(entry) {
   if (!entry || typeof entry !== "object") return entry;
@@ -8899,25 +9455,25 @@ function normalizeLegacyDiscussionEntry(entry) {
   return next;
 }
 function repoPoliciesDir(worktree) {
-  return path2.join(optimaDir(worktree), "policies");
+  return path5.join(optimaDir(worktree), "policies");
 }
 function generatedPoliciesDir(worktree) {
-  return path2.join(optimaLocalConfigDir(worktree), "generated", "policies");
+  return path5.join(optimaLocalConfigDir(worktree), "generated", "policies");
 }
 function generatedAgentsDir(worktree) {
-  return path2.join(optimaLocalConfigDir(worktree), "generated", "agents");
+  return path5.join(optimaLocalConfigDir(worktree), "generated", "agents");
 }
 function repoAgentsDir(worktree) {
-  return path2.join(optimaDir(worktree), "agents");
+  return path5.join(optimaDir(worktree), "agents");
 }
 function repoAgentAdditionsDir(worktree) {
-  return path2.join(optimaDir(worktree), "agent-additions");
+  return path5.join(optimaDir(worktree), "agent-additions");
 }
 function legacyRepoAgentsDir(worktree) {
-  return path2.join(legacyNomadworksDir(worktree), "agents");
+  return path5.join(legacyNomadworksDir(worktree), "agents");
 }
 function runtimeDiscussionRegistryPath(worktree) {
-  return path2.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
+  return path5.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
 }
 function resolveConfigPath(worktree) {
   return repoConfigPath(worktree);
@@ -8960,32 +9516,32 @@ function mergeClickUpAgentMetadata(existing, update = {}) {
   return JSON.stringify(sortJsonValue(merged), null, 2);
 }
 function optimaRuntimeDir(worktree) {
-  return path2.join(optimaLocalConfigDir(worktree), "runtime");
+  return path5.join(optimaLocalConfigDir(worktree), "runtime");
 }
 function clickUpWebhookStatePath(worktree) {
-  return path2.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
+  return path5.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
 }
 function clickUpCommentLedgerPath(worktree) {
-  return path2.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
+  return path5.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
 }
 function clickUpWebhookLogPath(worktree) {
-  return path2.join(optimaRuntimeDir(worktree), "clickup-webhook.log.jsonl");
+  return path5.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 && path2.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path2.join(os.homedir(), ".local", "share", "opencode");
-  return path2.join(dataHome, "opencode-optima");
+  const dataHome = process.env.XDG_DATA_HOME && path5.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path5.join(os.homedir(), ".local", "share", "opencode");
+  return path5.join(dataHome, "opencode-optima");
 }
 function clickUpWebhookAuditLogPath(at = /* @__PURE__ */ new Date(), logDir = clickUpWebhookAuditLogDir()) {
-  return path2.join(logDir, `clickup-webhook-${at.toISOString().slice(0, 10)}.jsonl`);
+  return path5.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 path2.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
+  return path5.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
 }
 function findOptimaPluginTupleOptions(pluginEntries = []) {
   if (!Array.isArray(pluginEntries)) return null;
@@ -9029,6 +9585,7 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
   const ignoredStatuses = Array.isArray(routing.ignored_statuses) && routing.ignored_statuses.length > 0 ? routing.ignored_statuses : CLICKUP_WEBHOOK_TERMINAL_STATUSES;
   const config = {
     enabled: raw.enabled === true,
+    test: raw.test === true || raw.test_mode === true || raw.testMode === true,
     basePath: String(raw.base_path || raw.basePath || worktree || "").trim(),
     teamId: String(raw.team_id || raw.teamId || "").trim(),
     apiToken: String(raw.api_token || raw.apiToken || "").trim(),
@@ -9067,7 +9624,7 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
   };
   const errors = [];
   if (!config.enabled) errors.push("clickup.enabled must be true");
-  if (!config.basePath || !path2.isAbsolute(config.basePath)) errors.push("clickup.base_path must be an absolute path");
+  if (!config.basePath || !path5.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");
@@ -9109,21 +9666,21 @@ function sanitizeClickUpWebhookState(state = {}, config = null) {
 }
 function readClickUpWebhookState(worktree, config = null) {
   const statePath = clickUpWebhookStatePath(worktree);
-  if (!fs2.existsSync(statePath)) return sanitizeClickUpWebhookState({}, config);
+  if (!fs5.existsSync(statePath)) return sanitizeClickUpWebhookState({}, config);
   try {
-    return sanitizeClickUpWebhookState(JSON.parse(fs2.readFileSync(statePath, "utf8")), config);
+    return sanitizeClickUpWebhookState(JSON.parse(fs5.readFileSync(statePath, "utf8")), config);
   } catch {
     return sanitizeClickUpWebhookState({}, config);
   }
 }
 function writeClickUpWebhookState(worktree, state, config = null) {
   const statePath = clickUpWebhookStatePath(worktree);
-  fs2.mkdirSync(path2.dirname(statePath), { recursive: true, mode: 448 });
+  fs5.mkdirSync(path5.dirname(statePath), { recursive: true, mode: 448 });
   const next = sanitizeClickUpWebhookState(state, config);
-  fs2.writeFileSync(statePath, `${JSON.stringify(next, null, 2)}
+  fs5.writeFileSync(statePath, `${JSON.stringify(next, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs2.chmodSync(statePath, 384);
+    fs5.chmodSync(statePath, 384);
   } catch {
   }
   return next;
@@ -9139,7 +9696,7 @@ function isClickUpWebhookStateActive(state, config) {
 function expandHomePath(value = "") {
   const input = String(value || "").trim();
   if (input === "~") return os.homedir();
-  if (input.startsWith("~/")) return path2.join(os.homedir(), input.slice(2));
+  if (input.startsWith("~/")) return path5.join(os.homedir(), input.slice(2));
   return input;
 }
 function resolveSecretReference(value = "") {
@@ -9149,7 +9706,7 @@ function resolveSecretReference(value = "") {
   const fileMatch = raw.match(/^\{file:(.+)\}$/);
   if (fileMatch) {
     try {
-      return fs2.readFileSync(expandHomePath(fileMatch[1]), "utf8").trim();
+      return fs5.readFileSync(expandHomePath(fileMatch[1]), "utf8").trim();
     } catch {
       return "";
     }
@@ -9226,6 +9783,40 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
     }
   };
 }
+function createTestClickUpApiClient(config) {
+  const metadata = /* @__PURE__ */ new Map();
+  return {
+    async createWebhook({ endpoint, events, location } = {}) {
+      return {
+        webhook: {
+          id: "optima-test-webhook",
+          endpoint: endpoint || config.webhook.publicUrl,
+          events: events || config.webhook.events,
+          location: location || config.webhook.location,
+          secret: "optima-test-secret",
+          active: true
+        }
+      };
+    },
+    async getTask(taskId) {
+      return null;
+    },
+    async updateTaskMetadata({ taskId, value }) {
+      metadata.set(String(taskId || ""), value);
+      return { ok: true };
+    },
+    async postTaskComment() {
+      return { ok: true };
+    },
+    async addTaskTag() {
+      return { ok: true };
+    },
+    async listAssignedTasks() {
+      return { tasks: [] };
+    },
+    __metadata: metadata
+  };
+}
 function normalizeClickUpWebhookApiResponse(response = {}, fallbackConfig = null) {
   const webhook = response?.webhook || response?.data || response || {};
   const healthStatus = String(webhook.health?.status || webhook.health_status || "").trim().toLowerCase();
@@ -9405,9 +9996,9 @@ function rememberClickUpWebhookEvent(state = {}, eventKey, limit = 200) {
 }
 function readClickUpCommentLedger(ledgerPath) {
   const processed = /* @__PURE__ */ new Set();
-  if (!ledgerPath || !fs2.existsSync(ledgerPath)) return processed;
+  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return processed;
   try {
-    const raw = fs2.readFileSync(ledgerPath, "utf8");
+    const raw = fs5.readFileSync(ledgerPath, "utf8");
     for (const [index, line] of raw.split(/\r?\n/).entries()) {
       if (!line.trim()) continue;
       try {
@@ -9424,11 +10015,11 @@ function readClickUpCommentLedger(ledgerPath) {
 }
 function appendClickUpCommentLedgerEntry(ledgerPath, entry = {}) {
   if (!ledgerPath || !entry.key) return;
-  fs2.mkdirSync(path2.dirname(ledgerPath), { recursive: true, mode: 448 });
-  fs2.appendFileSync(ledgerPath, `${JSON.stringify(entry)}
+  fs5.mkdirSync(path5.dirname(ledgerPath), { recursive: true, mode: 448 });
+  fs5.appendFileSync(ledgerPath, `${JSON.stringify(entry)}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs2.chmodSync(ledgerPath, 384);
+    fs5.chmodSync(ledgerPath, 384);
   } catch {
   }
 }
@@ -10144,9 +10735,9 @@ function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", w
 }
 function appendClickUpWebhookLocalLog(worktree, entry) {
   const logPath = clickUpWebhookLogPath(worktree);
-  fs2.mkdirSync(path2.dirname(logPath), { recursive: true });
+  fs5.mkdirSync(path5.dirname(logPath), { recursive: true });
   const safeEntry = { ...entry, at: entry.at || (/* @__PURE__ */ new Date()).toISOString() };
-  fs2.appendFileSync(logPath, `${JSON.stringify(safeEntry)}
+  fs5.appendFileSync(logPath, `${JSON.stringify(safeEntry)}
 `, "utf8");
 }
 function clickUpWebhookLifecycleLog(worktree, entry) {
@@ -10175,7 +10766,7 @@ function closeClickUpWebhookServer(server) {
   });
 }
 function managedClickUpWebhookKey({ worktree, state, config } = {}) {
-  return [path2.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
+  return [path5.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
 }
 async function deleteClickUpWebhookBestEffort({ webhookId, clickupClient, worktree, reason = "cleanup" } = {}) {
   const id = String(webhookId || "").trim();
@@ -10274,13 +10865,13 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
     const failed = Boolean(error || !handled?.ok || (handled?.status || 500) >= 400);
     if (level === "error" && !failed) return;
     const logDir = clickUpWebhookAuditLogDir();
-    fs2.mkdirSync(logDir, { recursive: true });
+    fs5.mkdirSync(logDir, { recursive: true });
     const secretValues = [resolveSecretReference(config?.apiToken), state?.secret, config?.webhook?.secret].filter(Boolean);
     let requestFile;
     if (level === "verbose") {
       const absoluteRequestFile = clickUpWebhookRequestFilePath(at, logDir);
-      fs2.mkdirSync(path2.dirname(absoluteRequestFile), { recursive: true });
-      requestFile = path2.relative(logDir, absoluteRequestFile).split(path2.sep).join("/");
+      fs5.mkdirSync(path5.dirname(absoluteRequestFile), { recursive: true });
+      requestFile = path5.relative(logDir, absoluteRequestFile).split(path5.sep).join("/");
       const parsedBody = payload || (() => {
         try {
           return JSON.parse(Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody || ""));
@@ -10296,11 +10887,11 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
         headers,
         body: parsedBody === void 0 ? Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody || "") : parsedBody
       }, secretValues);
-      fs2.writeFileSync(absoluteRequestFile, `${JSON.stringify(requestArtifact, null, 2)}
+      fs5.writeFileSync(absoluteRequestFile, `${JSON.stringify(requestArtifact, null, 2)}
 `, "utf8");
     }
     const summary = redactClickUpWebhookAuditValue(buildClickUpWebhookAuditSummary({ method, url, config, handled, error, payload, requestFile, at }), secretValues);
-    fs2.appendFileSync(clickUpWebhookAuditLogPath(at, logDir), `${JSON.stringify(summary)}
+    fs5.appendFileSync(clickUpWebhookAuditLogPath(at, logDir), `${JSON.stringify(summary)}
 `, "utf8");
   } catch {
   }
@@ -10374,7 +10965,7 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   const subtaskId = parentTaskId && parentTaskId !== taskId ? taskId : "";
   let taskRoute;
   try {
-    taskRoute = ensureTaskWorktree({ baseWorktree: config.basePath, taskId, taskType, parentTaskId, subtaskId, existingMetadata: metadata, allowNonGitFallback: process.env.NODE_ENV === "test" });
+    taskRoute = ensureTaskWorktree({ baseWorktree: config.basePath, taskId, taskType, parentTaskId, subtaskId, existingMetadata: metadata, allowNonGitFallback: process.env.NODE_ENV === "test" || config.test === true });
   } catch (error) {
     const message = `Optima webhook could not create or reuse a task worktree for ${taskId}: ${error.message}`;
     appendClickUpWebhookLocalLog(worktree, { type: "task_worktree_failed", taskId, message });
@@ -10656,7 +11247,7 @@ function clickUpListenerFingerprint({ config, state, worktree, clickupClient, op
   return JSON.stringify({
     publicUrl: config?.webhook?.publicUrl || "",
     path: clickUpWebhookExpectedPath(config),
-    worktree: path2.resolve(worktree || process.cwd()),
+    worktree: path5.resolve(worktree || process.cwd()),
     webhookId: state?.webhookId || "",
     secret: state?.secret || "",
     events: config?.webhook?.events || [],
@@ -10753,17 +11344,17 @@ function startClickUpWebhookListener({ config, state, worktree, clickupClient, o
   return result;
 }
 function legacyVariantPath(destinationPath) {
-  const parsed = path2.parse(destinationPath);
+  const parsed = path5.parse(destinationPath);
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-  if (parsed.ext) return path2.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
-  return path2.join(parsed.dir, `${parsed.base}.legacy-${stamp}`);
+  if (parsed.ext) return path5.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
+  return path5.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 (path2.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
+  if (path5.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
   if (normalized === "tasks" || normalized.startsWith("tasks/")) {
     return {
       ok: false,
@@ -10779,76 +11370,80 @@ function normalizeWorkflowTaskPath(taskPath) {
   return { ok: true, taskPath: trimmed };
 }
 function mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, gitState = null) {
+  const sourceWasTracked = isGitTracked(gitState, sourcePath);
   if (gitAwareMoveIfTracked(sourcePath, destinationPath, gitState)) return;
-  if (!fs2.existsSync(destinationPath)) {
-    fs2.mkdirSync(path2.dirname(destinationPath), { recursive: true });
-    fs2.renameSync(sourcePath, destinationPath);
+  if (!fs5.existsSync(destinationPath)) {
+    fs5.mkdirSync(path5.dirname(destinationPath), { recursive: true });
+    fs5.renameSync(sourcePath, destinationPath);
+    if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
-  const ext = path2.extname(destinationPath).toLowerCase();
+  const ext = path5.extname(destinationPath).toLowerCase();
   if ([".yaml", ".yml", ".json"].includes(ext)) {
-    const sourceRaw = fs2.readFileSync(sourcePath, "utf8");
-    const destRaw = fs2.readFileSync(destinationPath, "utf8");
-    const parser = ext === ".json" ? JSON : import_yaml2.default;
+    const sourceRaw = fs5.readFileSync(sourcePath, "utf8");
+    const destRaw = fs5.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_yaml2.default.stringify(merged);
-    fs2.writeFileSync(destinationPath, serialized, "utf8");
-    fs2.unlinkSync(sourcePath);
+` : import_yaml3.default.stringify(merged);
+    fs5.writeFileSync(destinationPath, serialized, "utf8");
+    fs5.unlinkSync(sourcePath);
     stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
   if (ext === ".md") {
-    const sourceRaw = fs2.readFileSync(sourcePath, "utf8").trimEnd();
-    const destRaw = fs2.readFileSync(destinationPath, "utf8").trimEnd();
+    const sourceRaw = fs5.readFileSync(sourcePath, "utf8").trimEnd();
+    const destRaw = fs5.readFileSync(destinationPath, "utf8").trimEnd();
     if (sourceRaw && !destRaw.includes(sourceRaw)) {
       const marker = `## Legacy Content From ${relativeSource}`;
-      fs2.writeFileSync(destinationPath, `${destRaw}
+      fs5.writeFileSync(destinationPath, `${destRaw}
 
 ${marker}
 
 ${sourceRaw}
 `, "utf8");
     }
-    fs2.unlinkSync(sourcePath);
+    fs5.unlinkSync(sourcePath);
     stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
   const preservedPath = legacyVariantPath(destinationPath);
-  fs2.renameSync(sourcePath, preservedPath);
+  fs5.renameSync(sourcePath, preservedPath);
   stageGitAwareMerge(sourcePath, preservedPath, gitState);
 }
-function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path2.basename(sourcePath), gitState = null) {
-  if (!fs2.existsSync(sourcePath)) return;
-  const stat = fs2.statSync(sourcePath);
+function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path5.basename(sourcePath), gitState = null) {
+  if (!fs5.existsSync(sourcePath)) return;
+  const stat = fs5.statSync(sourcePath);
   if (stat.isDirectory()) {
+    const sourceWasTracked = isGitTracked(gitState, sourcePath) || hasGitTrackedChildren(gitState, sourcePath);
     if (gitAwareMoveIfTracked(sourcePath, destinationPath, gitState)) return;
-    if (!fs2.existsSync(destinationPath)) {
-      fs2.mkdirSync(path2.dirname(destinationPath), { recursive: true });
-      fs2.renameSync(sourcePath, destinationPath);
+    if (!fs5.existsSync(destinationPath)) {
+      fs5.mkdirSync(path5.dirname(destinationPath), { recursive: true });
+      fs5.renameSync(sourcePath, destinationPath);
+      if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
       return;
     }
-    fs2.mkdirSync(destinationPath, { recursive: true });
-    for (const entry of fs2.readdirSync(sourcePath)) {
+    fs5.mkdirSync(destinationPath, { recursive: true });
+    for (const entry of fs5.readdirSync(sourcePath)) {
       mergePathIntoDestination(
-        path2.join(sourcePath, entry),
-        path2.join(destinationPath, entry),
-        path2.join(relativeSource, entry),
+        path5.join(sourcePath, entry),
+        path5.join(destinationPath, entry),
+        path5.join(relativeSource, entry),
         gitState
       );
     }
-    fs2.rmSync(sourcePath, { recursive: true, force: true });
+    fs5.rmSync(sourcePath, { recursive: true, force: true });
     return;
   }
   mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, gitState);
 }
 function isOptimaPluginPackageWorktree(worktree) {
-  const packageJsonPath = path2.join(worktree, "package.json");
-  if (!fs2.existsSync(packageJsonPath)) return false;
+  const packageJsonPath = path5.join(worktree, "package.json");
+  if (!fs5.existsSync(packageJsonPath)) return false;
   try {
-    const pkg = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
     return pkg?.name === "@defend-tech/opencode-optima";
   } catch {
     return false;
@@ -10857,59 +11452,59 @@ function isOptimaPluginPackageWorktree(worktree) {
 function migrateLegacyOptimaLayout(worktree) {
   const gitState = gitMigrationState(worktree);
   const migrations = [
-    [path2.join(legacyOrbitaDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path2.join(".orbita", "orbita.yaml")],
-    [path2.join(legacyOrbitaDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path2.join(".orbita", "staticeng.yaml")],
-    [path2.join(legacyOrbitaDir(worktree), ".config"), optimaLocalConfigDir(worktree), path2.join(".orbita", ".config")],
-    [path2.join(legacyOrbitaDir(worktree), "config"), optimaLocalConfigDir(worktree), path2.join(".orbita", "config")],
-    [path2.join(legacyOrbitaDir(worktree), "runtime"), path2.join(optimaLocalConfigDir(worktree), "runtime"), path2.join(".orbita", "runtime")],
-    [path2.join(legacyOrbitaDir(worktree), "generated"), path2.join(optimaLocalConfigDir(worktree), "generated"), path2.join(".orbita", "generated")],
+    [path5.join(legacyOrbitaDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path5.join(".orbita", "orbita.yaml")],
+    [path5.join(legacyOrbitaDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path5.join(".orbita", "staticeng.yaml")],
+    [path5.join(legacyOrbitaDir(worktree), ".config"), optimaLocalConfigDir(worktree), path5.join(".orbita", ".config")],
+    [path5.join(legacyOrbitaDir(worktree), "config"), optimaLocalConfigDir(worktree), path5.join(".orbita", "config")],
+    [path5.join(legacyOrbitaDir(worktree), "runtime"), path5.join(optimaLocalConfigDir(worktree), "runtime"), path5.join(".orbita", "runtime")],
+    [path5.join(legacyOrbitaDir(worktree), "generated"), path5.join(optimaLocalConfigDir(worktree), "generated"), path5.join(".orbita", "generated")],
     [legacyOrbitaDir(worktree), optimaDir(worktree), ".orbita"],
-    [path2.join(legacyStaticEngDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path2.join(".staticeng", "staticeng.yaml")],
-    [path2.join(legacyStaticEngDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path2.join(".staticeng", "orbita.yaml")],
-    [path2.join(legacyStaticEngDir(worktree), ".config"), optimaLocalConfigDir(worktree), path2.join(".staticeng", ".config")],
-    [path2.join(legacyStaticEngDir(worktree), "config"), optimaLocalConfigDir(worktree), path2.join(".staticeng", "config")],
-    [path2.join(legacyStaticEngDir(worktree), "runtime"), path2.join(optimaLocalConfigDir(worktree), "runtime"), path2.join(".staticeng", "runtime")],
-    [path2.join(legacyStaticEngDir(worktree), "generated"), path2.join(optimaLocalConfigDir(worktree), "generated"), path2.join(".staticeng", "generated")],
+    [path5.join(legacyStaticEngDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path5.join(".staticeng", "staticeng.yaml")],
+    [path5.join(legacyStaticEngDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path5.join(".staticeng", "orbita.yaml")],
+    [path5.join(legacyStaticEngDir(worktree), ".config"), optimaLocalConfigDir(worktree), path5.join(".staticeng", ".config")],
+    [path5.join(legacyStaticEngDir(worktree), "config"), optimaLocalConfigDir(worktree), path5.join(".staticeng", "config")],
+    [path5.join(legacyStaticEngDir(worktree), "runtime"), path5.join(optimaLocalConfigDir(worktree), "runtime"), path5.join(".staticeng", "runtime")],
+    [path5.join(legacyStaticEngDir(worktree), "generated"), path5.join(optimaLocalConfigDir(worktree), "generated"), path5.join(".staticeng", "generated")],
     [legacyStaticEngDir(worktree), optimaDir(worktree), ".staticeng"],
-    [path2.join(legacyNomadworkDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path2.join(".nomadwork", "nomadworks.yaml")],
-    [path2.join(legacyNomadworksDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path2.join(".nomadworks", "nomadworks.yaml")],
-    [path2.join(legacyNomadworkDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path2.join(".nomadwork", "staticeng.yaml")],
-    [path2.join(legacyNomadworksDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path2.join(".nomadworks", "staticeng.yaml")],
-    [path2.join(legacyNomadworkDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path2.join(".nomadwork", "orbita.yaml")],
-    [path2.join(legacyNomadworksDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path2.join(".nomadworks", "orbita.yaml")],
-    [path2.join(legacyNomadworkDir(worktree), "runtime"), path2.join(optimaLocalConfigDir(worktree), "runtime"), path2.join(".nomadwork", "runtime")],
-    [path2.join(legacyNomadworksDir(worktree), "runtime"), path2.join(optimaLocalConfigDir(worktree), "runtime"), path2.join(".nomadworks", "runtime")],
-    [path2.join(legacyNomadworkDir(worktree), "generated"), path2.join(optimaLocalConfigDir(worktree), "generated"), path2.join(".nomadwork", "generated")],
-    [path2.join(legacyNomadworksDir(worktree), "generated"), path2.join(optimaLocalConfigDir(worktree), "generated"), path2.join(".nomadworks", "generated")],
-    [path2.join(legacyNomadworkDir(worktree), "config"), optimaLocalConfigDir(worktree), path2.join(".nomadwork", "config")],
-    [path2.join(legacyNomadworksDir(worktree), "config"), optimaLocalConfigDir(worktree), path2.join(".nomadworks", "config")],
+    [path5.join(legacyNomadworkDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path5.join(".nomadwork", "nomadworks.yaml")],
+    [path5.join(legacyNomadworksDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path5.join(".nomadworks", "nomadworks.yaml")],
+    [path5.join(legacyNomadworkDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path5.join(".nomadwork", "staticeng.yaml")],
+    [path5.join(legacyNomadworksDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path5.join(".nomadworks", "staticeng.yaml")],
+    [path5.join(legacyNomadworkDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path5.join(".nomadwork", "orbita.yaml")],
+    [path5.join(legacyNomadworksDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path5.join(".nomadworks", "orbita.yaml")],
+    [path5.join(legacyNomadworkDir(worktree), "runtime"), path5.join(optimaLocalConfigDir(worktree), "runtime"), path5.join(".nomadwork", "runtime")],
+    [path5.join(legacyNomadworksDir(worktree), "runtime"), path5.join(optimaLocalConfigDir(worktree), "runtime"), path5.join(".nomadworks", "runtime")],
+    [path5.join(legacyNomadworkDir(worktree), "generated"), path5.join(optimaLocalConfigDir(worktree), "generated"), path5.join(".nomadwork", "generated")],
+    [path5.join(legacyNomadworksDir(worktree), "generated"), path5.join(optimaLocalConfigDir(worktree), "generated"), path5.join(".nomadworks", "generated")],
+    [path5.join(legacyNomadworkDir(worktree), "config"), optimaLocalConfigDir(worktree), path5.join(".nomadwork", "config")],
+    [path5.join(legacyNomadworksDir(worktree), "config"), optimaLocalConfigDir(worktree), path5.join(".nomadworks", "config")],
     [legacyNomadworkDir(worktree), optimaDir(worktree), ".nomadwork"],
     [legacyNomadworksDir(worktree), optimaDir(worktree), ".nomadworks"],
-    [path2.join(worktree, "tasks"), optimaTasksDir(worktree), "tasks"],
-    [path2.join(worktree, "evidences"), optimaEvidencesDir(worktree), "evidences"],
-    [path2.join(worktree, "docs", "scrs"), optimaScrsDir(worktree), path2.join("docs", "scrs")],
-    [path2.join(worktree, "codemap.yml"), optimaCodemapPath(worktree), "codemap.yml"],
-    [path2.join(worktree, "codemap.yaml"), optimaCodemapPath(worktree), "codemap.yaml"]
+    [path5.join(worktree, "tasks"), optimaTasksDir(worktree), "tasks"],
+    [path5.join(worktree, "evidences"), optimaEvidencesDir(worktree), "evidences"],
+    [path5.join(worktree, "docs", "scrs"), optimaScrsDir(worktree), path5.join("docs", "scrs")],
+    [path5.join(worktree, "codemap.yml"), optimaCodemapPath(worktree), "codemap.yml"],
+    [path5.join(worktree, "codemap.yaml"), optimaCodemapPath(worktree), "codemap.yaml"]
   ];
   if (!isOptimaPluginPackageWorktree(worktree)) {
-    migrations.push([path2.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
+    migrations.push([path5.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
   }
   for (const [source, destination, relativeSource] of migrations) {
-    if (fs2.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
+    if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
   for (const [source, destination, relativeSource] of [
-    [path2.join(optimaDir(worktree), "optima.yaml"), repoConfigPath(worktree), path2.join(".optima", "optima.yaml")],
-    [path2.join(optimaDir(worktree), "config"), optimaLocalConfigDir(worktree), path2.join(".optima", "config")],
-    [path2.join(optimaDir(worktree), "runtime"), path2.join(optimaLocalConfigDir(worktree), "runtime"), path2.join(".optima", "runtime")],
-    [path2.join(optimaDir(worktree), "generated"), path2.join(optimaLocalConfigDir(worktree), "generated"), path2.join(".optima", "generated")]
+    [path5.join(optimaDir(worktree), "optima.yaml"), repoConfigPath(worktree), path5.join(".optima", "optima.yaml")],
+    [path5.join(optimaDir(worktree), "config"), optimaLocalConfigDir(worktree), path5.join(".optima", "config")],
+    [path5.join(optimaDir(worktree), "runtime"), path5.join(optimaLocalConfigDir(worktree), "runtime"), path5.join(".optima", "runtime")],
+    [path5.join(optimaDir(worktree), "generated"), path5.join(optimaLocalConfigDir(worktree), "generated"), path5.join(".optima", "generated")]
   ]) {
-    if (fs2.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
+    if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
 }
 function listMarkdownFiles(dirPath) {
-  if (!fs2.existsSync(dirPath)) return [];
+  if (!fs5.existsSync(dirPath)) return [];
   try {
-    return fs2.readdirSync(dirPath).filter((file) => file.endsWith(".md") && file.toLowerCase() !== "readme.md");
+    return fs5.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 [];
@@ -10919,67 +11514,6 @@ function normalizePolicyExtraction(value) {
   if (typeof value !== "string") return "none";
   return value.trim().toLowerCase() === "all" ? "all" : "none";
 }
-function resolveIncludeFile(includeRef, repoRoot, bundleRoot, options = {}) {
-  const trimmed = includeRef.trim();
-  const scopedMatch = trimmed.match(/^([a-z]+):(.*)$/i);
-  const scope = scopedMatch?.[1]?.toLowerCase();
-  const target = scopedMatch ? scopedMatch[2].trim() : trimmed;
-  const resolveRelative = (baseDir, relativePath) => {
-    if (!relativePath) return null;
-    return path2.isAbsolute(relativePath) ? relativePath : path2.join(baseDir, relativePath);
-  };
-  const withCompactPreference = (paths) => {
-    if (!options.preferCompactPromptDocs) return paths;
-    const compactPaths = paths.map((filePath) => filePath ? compactPromptPath(filePath) : null).filter(Boolean);
-    return [...compactPaths, ...paths];
-  };
-  if (scope === "plugin") {
-    for (const filePath of withCompactPreference([resolveRelative(bundleRoot, target)])) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
-    }
-    return null;
-  }
-  if (scope === "repo") {
-    for (const filePath of withCompactPreference([resolveRelative(optimaDir(repoRoot), target)])) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
-    }
-    return null;
-  }
-  if (scope === "policy") {
-    const candidates2 = withCompactPreference([
-      resolveRelative(repoPoliciesDir(repoRoot), target),
-      resolveRelative(BUNDLE_POLICIES_DIR, target)
-    ]);
-    for (const filePath of candidates2) {
-      if (filePath && fs2.existsSync(filePath)) return filePath;
-    }
-    return null;
-  }
-  const candidates = withCompactPreference([
-    resolveRelative(repoRoot, target),
-    resolveRelative(bundleRoot, target)
-  ]);
-  for (const filePath of candidates) {
-    if (filePath && fs2.existsSync(filePath)) return filePath;
-  }
-  return null;
-}
-function resolveIncludes(text, repoRoot, bundleRoot, options = {}) {
-  const includeRegex = /<include:(.*?)>/g;
-  return text.replace(includeRegex, (match, includeRef) => {
-    const filePath = resolveIncludeFile(includeRef, repoRoot, bundleRoot, options);
-    if (!filePath) {
-      console.warn(`[Optima] Include file not found: ${includeRef}`);
-      return `
-
-# ERROR: Include file not found: ${includeRef}
-
-`;
-    }
-    const content = fs2.readFileSync(filePath, "utf8");
-    return resolveIncludes(content, repoRoot, bundleRoot, options);
-  });
-}
 function parseFrontmatter(mdText) {
   const lines = mdText.split(/\r?\n/);
   if (lines[0]?.trim() !== "---") return { data: {}, body: mdText };
@@ -10994,7 +11528,7 @@ function parseFrontmatter(mdText) {
   const fmText = lines.slice(1, end).join("\n");
   const body = lines.slice(end + 1).join("\n");
   try {
-    return { data: import_yaml2.default.parse(fmText) || {}, body };
+    return { data: import_yaml3.default.parse(fmText) || {}, body };
   } catch {
     return { data: {}, body };
   }
@@ -11011,10 +11545,10 @@ function toModelString(provider, model) {
 }
 function readTaskMetadata(taskPath, worktree) {
   if (!taskPath) return {};
-  const absoluteTaskPath = path2.isAbsolute(taskPath) ? taskPath : path2.join(worktree, taskPath);
-  if (!fs2.existsSync(absoluteTaskPath)) return {};
+  const absoluteTaskPath = path5.isAbsolute(taskPath) ? taskPath : path5.join(worktree, taskPath);
+  if (!fs5.existsSync(absoluteTaskPath)) return {};
   try {
-    const raw = fs2.readFileSync(absoluteTaskPath, "utf8");
+    const raw = fs5.readFileSync(absoluteTaskPath, "utf8");
     const { data } = parseFrontmatter(raw);
     return {
       complexity: typeof data.complexity === "string" ? data.complexity.trim().toLowerCase() : void 0,
@@ -11039,11 +11573,11 @@ function slugifyTitle(input) {
 }
 function loadDiscussionRegistry(worktree) {
   const registryPath = runtimeDiscussionRegistryPath(worktree);
-  if (!fs2.existsSync(registryPath)) {
+  if (!fs5.existsSync(registryPath)) {
     return { version: 1, active: {} };
   }
   try {
-    const parsed = JSON.parse(fs2.readFileSync(registryPath, "utf8"));
+    const parsed = JSON.parse(fs5.readFileSync(registryPath, "utf8"));
     const registry = {
       version: 1,
       active: Object.fromEntries(Object.entries(parsed.active || {}).map(([key, value]) => [key, normalizeLegacyDiscussionEntry(value)]))
@@ -11056,34 +11590,34 @@ function loadDiscussionRegistry(worktree) {
 }
 function saveDiscussionRegistry(worktree, registry) {
   const registryPath = runtimeDiscussionRegistryPath(worktree);
-  const runtimeDir = path2.dirname(registryPath);
-  if (!fs2.existsSync(runtimeDir)) fs2.mkdirSync(runtimeDir, { recursive: true });
-  fs2.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
+  const runtimeDir = path5.dirname(registryPath);
+  if (!fs5.existsSync(runtimeDir)) fs5.mkdirSync(runtimeDir, { recursive: true });
+  fs5.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
 }
 function runtimeDiscussionsDir(worktree) {
-  return path2.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
+  return path5.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
 }
 function archivedRuntimeDiscussionsDir(worktree) {
-  return path2.join(runtimeDiscussionsDir(worktree), "archive");
+  return path5.join(runtimeDiscussionsDir(worktree), "archive");
 }
 function finalDiscussionsDir(worktree) {
-  return path2.join(optimaTasksDir(worktree), "discussions");
+  return path5.join(optimaTasksDir(worktree), "discussions");
 }
 function nextDiscussionIdentity(worktree, title) {
   const discussionsDir = finalDiscussionsDir(worktree);
   const runtimeDir = runtimeDiscussionsDir(worktree);
-  if (!fs2.existsSync(discussionsDir)) fs2.mkdirSync(discussionsDir, { recursive: true });
-  if (!fs2.existsSync(runtimeDir)) fs2.mkdirSync(runtimeDir, { recursive: true });
+  if (!fs5.existsSync(discussionsDir)) fs5.mkdirSync(discussionsDir, { recursive: true });
+  if (!fs5.existsSync(runtimeDir)) fs5.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 = path2.join(".optima", "tasks", "discussions", filename);
-    const summaryAbsolutePath = path2.join(worktree, summaryRelativePath);
+    const summaryRelativePath = path5.join(".optima", "tasks", "discussions", filename);
+    const summaryAbsolutePath = path5.join(worktree, summaryRelativePath);
     const transcriptFilename = `${id}-transcript.md`;
-    const transcriptRelativePath = path2.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
-    const transcriptAbsolutePath = path2.join(worktree, transcriptRelativePath);
-    if (!fs2.existsSync(summaryAbsolutePath) && !fs2.existsSync(transcriptAbsolutePath)) {
+    const transcriptRelativePath = path5.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
+    const transcriptAbsolutePath = path5.join(worktree, transcriptRelativePath);
+    if (!fs5.existsSync(summaryAbsolutePath) && !fs5.existsSync(transcriptAbsolutePath)) {
       return {
         id,
         filename,
@@ -11099,37 +11633,37 @@ function nextDiscussionIdentity(worktree, title) {
 }
 function findDiscussionById(worktree, discussionID) {
   const discussionsDir = finalDiscussionsDir(worktree);
-  if (!fs2.existsSync(discussionsDir)) return null;
-  const entries = fs2.readdirSync(discussionsDir).filter((name) => name.startsWith(`${discussionID}-`) && name.endsWith(".md"));
+  if (!fs5.existsSync(discussionsDir)) return null;
+  const entries = fs5.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: path2.join(".optima", "tasks", "discussions", filename),
-    summaryAbsolutePath: path2.join(discussionsDir, filename),
+    summaryRelativePath: path5.join(".optima", "tasks", "discussions", filename),
+    summaryAbsolutePath: path5.join(discussionsDir, filename),
     transcriptFilename,
-    transcriptRelativePath: path2.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
-    transcriptAbsolutePath: path2.join(runtimeDiscussionsDir(worktree), transcriptFilename)
+    transcriptRelativePath: path5.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
+    transcriptAbsolutePath: path5.join(runtimeDiscussionsDir(worktree), transcriptFilename)
   };
 }
 function parseDiscussionFile(filePath) {
-  const raw = fs2.readFileSync(filePath, "utf8");
+  const raw = fs5.readFileSync(filePath, "utf8");
   const { data, body } = parseFrontmatter(raw);
   return { data, body: body.trimStart() };
 }
 function writeDiscussionFile(filePath, frontmatter, body) {
   const serialized = `---
-${import_yaml2.default.stringify(frontmatter).trim()}
+${import_yaml3.default.stringify(frontmatter).trim()}
 ---
 
 ${body.trimEnd()}
 `;
-  fs2.writeFileSync(filePath, serialized, "utf8");
+  fs5.writeFileSync(filePath, serialized, "utf8");
 }
 function setDiscussionStatus(filePath, status) {
-  if (!fs2.existsSync(filePath)) return;
+  if (!fs5.existsSync(filePath)) return;
   const { data, body } = parseDiscussionFile(filePath);
   writeDiscussionFile(filePath, { ...data, status }, body);
 }
@@ -11194,18 +11728,18 @@ async function appendMessageIfNeeded(client, worktree, registry, sessionID, mess
   });
   const text = extractTextParts(response.data.parts || []);
   if (!text) return;
-  appendDiscussionMessage(path2.join(worktree, discussion.transcriptPath), speaker, text, messageID);
+  appendDiscussionMessage(path5.join(worktree, discussion.transcriptPath), speaker, text, messageID);
   discussion.appendedMessageIDs ??= [];
   discussion.appendedMessageIDs.push(messageID);
   saveDiscussionRegistry(worktree, registry);
 }
 async function summarizeDiscussionWithBA(client, worktree, discussion) {
-  const transcriptPath = path2.join(worktree, discussion.transcriptPath);
-  const summaryPath = path2.join(worktree, discussion.summaryPath);
-  const summaryDir = path2.dirname(summaryPath);
-  if (!fs2.existsSync(summaryDir)) fs2.mkdirSync(summaryDir, { recursive: true });
-  const hasExistingSummary = fs2.existsSync(summaryPath);
-  const priorMtimeMs = hasExistingSummary ? fs2.statSync(summaryPath).mtimeMs : null;
+  const transcriptPath = path5.join(worktree, discussion.transcriptPath);
+  const summaryPath = path5.join(worktree, discussion.summaryPath);
+  const summaryDir = path5.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 summarizerSession = await client.session.create({
     body: { title: `Discussion Summary: ${discussion.id}` }
   });
@@ -11305,30 +11839,30 @@ async function summarizeDiscussionWithBA(client, worktree, discussion) {
   return { confirmation, summaryPath, transcriptPath, hasExistingSummary, priorMtimeMs };
 }
 function archiveDiscussionTranscript(worktree, transcriptRelativePath) {
-  const sourcePath = path2.join(worktree, transcriptRelativePath);
-  if (!fs2.existsSync(sourcePath)) return null;
+  const sourcePath = path5.join(worktree, transcriptRelativePath);
+  if (!fs5.existsSync(sourcePath)) return null;
   const archiveDir = archivedRuntimeDiscussionsDir(worktree);
-  if (!fs2.existsSync(archiveDir)) fs2.mkdirSync(archiveDir, { recursive: true });
-  const targetPath = path2.join(archiveDir, path2.basename(sourcePath));
-  fs2.renameSync(sourcePath, targetPath);
+  if (!fs5.existsSync(archiveDir)) fs5.mkdirSync(archiveDir, { recursive: true });
+  const targetPath = path5.join(archiveDir, path5.basename(sourcePath));
+  fs5.renameSync(sourcePath, targetPath);
   return targetPath;
 }
 async function finalizeClosingDiscussion(client, worktree, registry, sessionID, discussion) {
   const { confirmation, summaryPath, hasExistingSummary, priorMtimeMs } = await summarizeDiscussionWithBA(client, worktree, discussion);
-  if (!fs2.existsSync(summaryPath)) {
+  if (!fs5.existsSync(summaryPath)) {
     throw new Error(`Discussion summary was not written to ${discussion.summaryPath}`);
   }
   if (hasExistingSummary) {
-    const currentMtimeMs = fs2.statSync(summaryPath).mtimeMs;
+    const currentMtimeMs = fs5.statSync(summaryPath).mtimeMs;
     if (currentMtimeMs <= priorMtimeMs) {
       throw new Error(`Discussion summary file was not updated at ${discussion.summaryPath}`);
     }
   }
-  const summaryContent = fs2.readFileSync(summaryPath, "utf8").trim();
+  const summaryContent = fs5.readFileSync(summaryPath, "utf8").trim();
   if (!summaryContent) {
     throw new Error(`Discussion summary file is empty at ${discussion.summaryPath}`);
   }
-  const transcriptPath = path2.join(worktree, discussion.transcriptPath);
+  const transcriptPath = path5.join(worktree, discussion.transcriptPath);
   setDiscussionStatus(transcriptPath, "closed");
   const archivedTranscriptPath = archiveDiscussionTranscript(worktree, discussion.transcriptPath);
   delete registry.active[sessionID];
@@ -11336,7 +11870,7 @@ async function finalizeClosingDiscussion(client, worktree, registry, sessionID,
   return {
     confirmation,
     summaryPath: discussion.summaryPath,
-    archivedTranscriptPath: archivedTranscriptPath ? path2.relative(worktree, archivedTranscriptPath) : path2.join(".optima", ".config", "runtime", "discussions", "archive", path2.basename(discussion.transcriptPath))
+    archivedTranscriptPath: archivedTranscriptPath ? path5.relative(worktree, archivedTranscriptPath) : path5.join(".optima", ".config", "runtime", "discussions", "archive", path5.basename(discussion.transcriptPath))
   };
 }
 function normalizeTeamMode(value) {
@@ -11375,13 +11909,13 @@ function getOperatingTeamMode(repoCfg) {
 }
 function readResolvedFile(relativePath, worktree, options = {}) {
   const filePath = resolveIncludeFile(`plugin:${relativePath}`, worktree, PKG_ROOT, options);
-  if (!filePath || !fs2.existsSync(filePath)) return "";
-  return resolveIncludes(fs2.readFileSync(filePath, "utf8"), worktree, PKG_ROOT, options).trim();
+  if (!filePath || !fs5.existsSync(filePath)) return "";
+  return resolveIncludes(fs5.readFileSync(filePath, "utf8"), worktree, PKG_ROOT, options).trim();
 }
 function loadMarkdownFragment(filePath, worktree) {
-  if (!fs2.existsSync(filePath)) return "";
+  if (!fs5.existsSync(filePath)) return "";
   try {
-    const raw = fs2.readFileSync(filePath, "utf8");
+    const raw = fs5.readFileSync(filePath, "utf8");
     const { body } = parseFrontmatter(raw);
     return resolveIncludes(body.trim(), worktree, PKG_ROOT);
   } catch (e) {
@@ -11390,9 +11924,9 @@ function loadMarkdownFragment(filePath, worktree) {
   }
 }
 function loadAgentDefinition(filePath, worktree, options = {}) {
-  if (!fs2.existsSync(filePath)) return null;
+  if (!fs5.existsSync(filePath)) return null;
   try {
-    const rawContent = fs2.readFileSync(filePath, "utf8");
+    const rawContent = fs5.readFileSync(filePath, "utf8");
     const { data, body } = parseFrontmatter(rawContent);
     const prompt = resolveIncludes(body.trim(), worktree, PKG_ROOT, options);
     return { data, prompt };
@@ -11403,13 +11937,13 @@ function loadAgentDefinition(filePath, worktree, options = {}) {
 }
 function syncGeneratedPolicies(worktree, repoCfg) {
   if (repoCfg.policies?.extract_defaults !== "all") return;
-  if (!fs2.existsSync(BUNDLE_POLICIES_DIR)) return;
+  if (!fs5.existsSync(BUNDLE_POLICIES_DIR)) return;
   const generatedDir = generatedPoliciesDir(worktree);
-  if (!fs2.existsSync(generatedDir)) fs2.mkdirSync(generatedDir, { recursive: true });
-  const policyFiles = fs2.readdirSync(BUNDLE_POLICIES_DIR).filter((file) => file.endsWith(".md") && file !== "README.md");
+  if (!fs5.existsSync(generatedDir)) fs5.mkdirSync(generatedDir, { recursive: true });
+  const policyFiles = fs5.readdirSync(BUNDLE_POLICIES_DIR).filter((file) => file.endsWith(".md") && file !== "README.md");
   for (const file of policyFiles) {
-    const sourcePath = path2.join(BUNDLE_POLICIES_DIR, file);
-    const source = fs2.readFileSync(sourcePath, "utf8").trimEnd();
+    const sourcePath = path5.join(BUNDLE_POLICIES_DIR, file);
+    const source = fs5.readFileSync(sourcePath, "utf8").trimEnd();
     const generated = [
       "<!--",
       "Generated from Optima plugin defaults.",
@@ -11420,19 +11954,31 @@ function syncGeneratedPolicies(worktree, repoCfg) {
       source,
       ""
     ].join("\n");
-    fs2.writeFileSync(path2.join(generatedDir, file), generated, "utf8");
+    fs5.writeFileSync(path5.join(generatedDir, file), generated, "utf8");
   }
 }
 function ensureReadmeFile(dirPath, content) {
-  if (!fs2.existsSync(dirPath)) fs2.mkdirSync(dirPath, { recursive: true });
-  const readmePath = path2.join(dirPath, "README.md");
-  if (!fs2.existsSync(readmePath)) {
-    fs2.writeFileSync(readmePath, content, "utf8");
+  if (!fs5.existsSync(dirPath)) fs5.mkdirSync(dirPath, { recursive: true });
+  const readmePath = path5.join(dirPath, "README.md");
+  if (!fs5.existsSync(readmePath)) {
+    fs5.writeFileSync(readmePath, content, "utf8");
   }
 }
 function ensureFileIfMissing(filePath, content) {
-  if (!fs2.existsSync(path2.dirname(filePath))) fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
-  if (!fs2.existsSync(filePath)) fs2.writeFileSync(filePath, content, "utf8");
+  if (!fs5.existsSync(path5.dirname(filePath))) fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+  if (!fs5.existsSync(filePath)) fs5.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";
+}
+function doneTasksRegistryContent() {
+  return "# Completed Tasks (Registry)\n\n| Date | Task ID | SCR ID | Commit | Summary |\n| :--- | :--- | :--- | :--- | :--- |\n";
+}
+function currentScrRegistryContent() {
+  return "# Current Spec Change Requests (Backlog)\n\n## \u{1F680} Active/Review\n- (None)\n\n## \u{1F4CB} Approved (Ready for Implementation)\n- (None)\n\n## \u{1F4A1} Proposed\n- (None)\n";
+}
+function doneScrRegistryContent() {
+  return "# Implemented Spec Change Requests\n\n| Date | SCR ID | Title | Related Feature | Task ID |\n| :--- | :--- | :--- | :--- | :--- |\n";
 }
 function taskTemplateContent() {
   return `---
@@ -11506,19 +12052,58 @@ Never place implementation evidence under root \`evidences/\`.
 }
 function ensureOptimaTaskTemplates(worktree) {
   const tasksDir = optimaTasksDir(worktree);
-  ensureFileIfMissing(path2.join(tasksDir, "task-template.md"), taskTemplateContent());
-  ensureFileIfMissing(path2.join(tasksDir, "subtask-template.md"), subtaskTemplateContent());
+  ensureFileIfMissing(path5.join(tasksDir, "task-template.md"), taskTemplateContent());
+  ensureFileIfMissing(path5.join(tasksDir, "subtask-template.md"), subtaskTemplateContent());
+}
+function scaffoldOptimaConfig(worktree, teamMode = "full") {
+  const configPath = repoConfigPath(worktree);
+  if (fs5.existsSync(configPath)) return false;
+  const templatePath = path5.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");
+  optimaConfig = optimaConfig.replace("{{teamMode}}", normalizeTeamMode(teamMode));
+  let agentsSection = "";
+  for (const id of agentIds) {
+    const enabled = isAgentEnabledForTeamMode(id, normalizeTeamMode(teamMode)) ? "true" : "false";
+    agentsSection += `  ${id}:
+    enabled: ${enabled}
+`;
+  }
+  optimaConfig = optimaConfig.replace(/^agents:/m, "agents:\n" + agentsSection);
+  ensureFileIfMissing(configPath, optimaConfig);
+  return fs5.existsSync(configPath);
+}
+function scaffoldOptimaRootCodemap(worktree) {
+  const rootCodemapPath = optimaCodemapPath(worktree);
+  if (fs5.existsSync(rootCodemapPath)) return false;
+  const templatePath = path5.join(TEMPLATES_DIR, "codemap.yml.template");
+  if (!fs5.existsSync(templatePath)) return false;
+  const codemapConfig = fs5.readFileSync(templatePath, "utf8").replace("{{projectName}}", path5.basename(worktree));
+  ensureFileIfMissing(rootCodemapPath, codemapConfig);
+  return fs5.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(path5.join(tasksDir, "current.md"), currentTasksRegistryContent());
+  ensureFileIfMissing(path5.join(tasksDir, "done.md"), doneTasksRegistryContent());
+  ensureFileIfMissing(path5.join(scrsDir, "current.md"), currentScrRegistryContent());
+  ensureFileIfMissing(path5.join(scrsDir, "done.md"), doneScrRegistryContent());
 }
 function scaffoldOptimaReadmes(worktree) {
   ensureReadmeFile(repoPoliciesDir(worktree), REPO_LOCAL_POLICIES_README);
   ensureReadmeFile(repoAgentsDir(worktree), [
     "# Repository Agents",
     "",
-    "Place full repository-local agent definitions here.",
+    "Place full repository-local agent definitions here only when explicitly requested by the user.",
     "",
-    "- Use `.optima/agents/<agent>.md` to override a bundled agent's full base definition.",
-    "- Use `.optima/agents/<agent>.md` to define a brand new custom repository agent.",
-    "- Files in this folder are treated as full agent definitions.",
+    "- Use `.optima/agents/<agent>.md` only to intentionally override a bundled agent's full base definition.",
+    "- Use `.optima/agents/<agent>.md` only to define a brand new custom repository agent.",
+    "- Files in this folder are treated as full agent definitions and block bundled prompt updates for that agent.",
+    "- Prefer `.optima/agent-additions/<agent>.md` for normal repository-specific guidance.",
     "- `README.md` is ignored by agent discovery.",
     "",
     "## Include Types Available In Custom Agents",
@@ -11612,6 +12197,38 @@ function scaffoldOptimaReadmes(worktree) {
   ].join("\n"));
   ensureOptimaTaskTemplates(worktree);
 }
+function optimaRepairDependencies() {
+  return {
+    currentScrRegistryContent,
+    currentTasksRegistryContent,
+    doneScrRegistryContent,
+    doneTasksRegistryContent,
+    ensureFileIfMissing,
+    ensureOptimaGitignoreRules,
+    ensureOptimaRegistries,
+    isGitRepository,
+    isOptimaPluginPackageWorktree,
+    legacyNomadworkDir,
+    legacyNomadworksDir,
+    legacyOrbitaDir,
+    legacyStaticEngDir,
+    migrateLegacyOptimaLayout,
+    optimaCodemapPath,
+    optimaDir,
+    optimaEvidencesDir,
+    optimaGitignoreRules: OPTIMA_GITIGNORE_RULES,
+    optimaScrsDir,
+    optimaTasksDir,
+    repoConfigPath,
+    repoLocalPoliciesReadme: REPO_LOCAL_POLICIES_README,
+    repoPoliciesDir,
+    scaffoldOptimaConfig,
+    scaffoldOptimaReadmes,
+    scaffoldOptimaRootCodemap,
+    subtaskTemplateContent,
+    taskTemplateContent
+  };
+}
 function getModePromptFragment(agentId, operatingTeamMode, worktree) {
   const fragmentMap = {
     product_manager: {
@@ -11627,13 +12244,6 @@ function getModePromptFragment(agentId, operatingTeamMode, worktree) {
   if (!fragmentPath) return "";
   return readResolvedFile(fragmentPath, worktree, { preferCompactPromptDocs: true });
 }
-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);
-}
 function shouldRegisterWorkflowProductManager(options = {}, worktree = process.cwd()) {
   if (options.clickUpWebhookActive === true) return true;
   const validation = options.clickUpWebhookValidation;
@@ -11642,12 +12252,12 @@ function shouldRegisterWorkflowProductManager(options = {}, worktree = process.c
 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() ? path2.resolve(safe.worktree, String(requestedDirectory).trim()) : safe.worktree;
+  const requested = String(requestedDirectory || "").trim() ? path5.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: path2.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path5.resolve(clickUpBasePath) };
   }
   return {
     ok: false,
@@ -11681,8 +12291,8 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
       if (!enabled) continue;
     }
     const promptOptions = { preferCompactPromptDocs: repoCfg.features?.compact_prompt_docs !== false };
-    const bundledDefinition = loadAgentDefinition(path2.join(BUNDLE_AGENTS_DIR, file), worktree, promptOptions);
-    const repoDefinition = loadAgentDefinition(path2.join(repoAgentDefinitions, file), worktree, promptOptions) || loadAgentDefinition(path2.join(legacyAgentsDir, file), worktree, promptOptions);
+    const bundledDefinition = loadAgentDefinition(path5.join(BUNDLE_AGENTS_DIR, file), worktree, promptOptions);
+    const repoDefinition = loadAgentDefinition(path5.join(repoAgentDefinitions, file), worktree, promptOptions) || loadAgentDefinition(path5.join(legacyAgentsDir, file), worktree, promptOptions);
     const activeDefinition = repoDefinition || bundledDefinition;
     if (!activeDefinition) continue;
     const { data } = activeDefinition;
@@ -11691,7 +12301,7 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
     if (modePromptFragment) finalPrompt = `${finalPrompt}
 
 ${modePromptFragment}`;
-    const additionFragment = loadMarkdownFragment(path2.join(repoAgentAdditions, file), worktree);
+    const additionFragment = loadMarkdownFragment(path5.join(repoAgentAdditions, file), worktree);
     if (additionFragment) {
       finalPrompt = `${finalPrompt}
 
@@ -11744,14 +12354,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 = path2.join(debugDir, `${id}.md`);
+      const debugPath = path5.join(debugDir, `${id}.md`);
       const { prompt, ...dumpConfig } = agentConfig;
       const debugHeader = `---
-${import_yaml2.default.stringify(dumpConfig).trim()}
+${import_yaml3.default.stringify(dumpConfig).trim()}
 ---`;
       try {
-        if (!fs2.existsSync(debugDir)) fs2.mkdirSync(debugDir, { recursive: true });
-        fs2.writeFileSync(debugPath, `${debugHeader}
+        if (!fs5.existsSync(debugDir)) fs5.mkdirSync(debugDir, { recursive: true });
+        fs5.writeFileSync(debugPath, `${debugHeader}
 
 ${prompt}`, "utf8");
       } catch (e) {
@@ -11775,9 +12385,9 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   const configPath = resolveConfigPath(worktree);
   const discussionRegistry = loadDiscussionRegistry(worktree);
   let repoCfg = { agents: {}, defaults: {}, features: {} };
-  if (fs2.existsSync(configPath)) {
+  if (fs5.existsSync(configPath)) {
     try {
-      repoCfg = import_yaml2.default.parse(fs2.readFileSync(configPath, "utf8")) || repoCfg;
+      repoCfg = import_yaml3.default.parse(fs5.readFileSync(configPath, "utf8")) || repoCfg;
     } catch (e) {
       console.error(`[Optima] Failed to parse config at ${configPath}:`, e);
     }
@@ -11790,13 +12400,14 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   syncGeneratedPolicies(worktree, repoCfg);
   const operatingTeamMode = getOperatingTeamMode(repoCfg);
   const clickUpWebhookValidation = normalizeClickUpWebhookConfig(pickConfiguredClickUp(input, repoCfg, resolvedPluginOptions), worktree);
+  const runtimeClickUpClient = input.clickupClient || (clickUpWebhookValidation.config?.test === true ? createTestClickUpApiClient(clickUpWebhookValidation.config) : createClickUpApiClient(clickUpWebhookValidation.config, input.fetch));
   let clickUpWebhookRuntime = { active: false, valid: false, reason: "not_configured" };
   if (clickUpWebhookValidation.complete) {
     try {
       clickUpWebhookRuntime = await ensureClickUpWebhookSubscription({
         validation: clickUpWebhookValidation,
         worktree,
-        clickupClient: input.clickupClient || createClickUpApiClient(clickUpWebhookValidation.config, input.fetch)
+        clickupClient: runtimeClickUpClient
       });
     } catch (error) {
       clickUpWebhookRuntime = { active: false, valid: false, reason: "subscription_failed", error: error.message };
@@ -11806,7 +12417,7 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
   let clickUpWebhookActive = clickUpWebhookRuntime.active === true && clickUpWebhookRuntime.valid === true;
   if (clickUpWebhookActive && input.startClickUpWebhookListener !== false) {
     try {
-      const lifecycleClickUpClient = input.clickupClient || createClickUpApiClient(clickUpWebhookValidation.config, input.fetch);
+      const lifecycleClickUpClient = runtimeClickUpClient;
       const listenerRegistry = input.clickUpWebhookListenerRegistry || activeClickUpWebhookListeners;
       const listenerState = clickUpWebhookRuntime.state || readClickUpWebhookState(worktree, clickUpWebhookValidation.config);
       const listener = startClickUpWebhookListener({
@@ -11884,54 +12495,16 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
         }
         migrateLegacyOptimaLayout(toolWorktree);
         const cfgDir = optimaConfigDir(toolWorktree);
-        if (!fs2.existsSync(cfgDir)) fs2.mkdirSync(cfgDir, { recursive: true });
-        const agentIds = fs2.existsSync(BUNDLE_AGENTS_DIR) ? fs2.readdirSync(BUNDLE_AGENTS_DIR).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")) : [];
-        const optimaTmplPath = path2.join(TEMPLATES_DIR, "optima.yaml.template");
-        const codemapTmplPath = path2.join(TEMPLATES_DIR, "codemap.yml.template");
-        if (!fs2.existsSync(optimaTmplPath) || !fs2.existsSync(codemapTmplPath)) {
+        if (!fs5.existsSync(cfgDir)) fs5.mkdirSync(cfgDir, { recursive: true });
+        const optimaTmplPath = path5.join(TEMPLATES_DIR, "optima.yaml.template");
+        const codemapTmplPath = path5.join(TEMPLATES_DIR, "codemap.yml.template");
+        if (!fs5.existsSync(optimaTmplPath) || !fs5.existsSync(codemapTmplPath)) {
           return "Error: Initialization templates not found in plugin.";
         }
-        let optimaConfig = fs2.readFileSync(optimaTmplPath, "utf8");
-        optimaConfig = optimaConfig.replace("{{teamMode}}", requestedTeamMode);
-        let agentsSection = "";
-        for (const id of agentIds) {
-          const enabled = isAgentEnabledForTeamMode(id, requestedTeamMode) ? "true" : "false";
-          agentsSection += `  ${id}:
-    enabled: ${enabled}
-`;
-        }
-        optimaConfig = optimaConfig.replace(/^agents:/m, "agents:\n" + agentsSection);
-        let codemapConfig = fs2.readFileSync(codemapTmplPath, "utf8");
-        codemapConfig = codemapConfig.replace("{{projectName}}", path2.basename(toolWorktree));
-        const cfgFilePath = repoConfigPath(toolWorktree);
-        const rootCodemapPath = optimaCodemapPath(toolWorktree);
-        if (!fs2.existsSync(cfgFilePath)) {
-          fs2.writeFileSync(cfgFilePath, optimaConfig, "utf8");
-        }
-        if (!fs2.existsSync(rootCodemapPath)) {
-          fs2.writeFileSync(rootCodemapPath, codemapConfig, "utf8");
-        }
+        scaffoldOptimaConfig(toolWorktree, requestedTeamMode);
+        scaffoldOptimaRootCodemap(toolWorktree);
         scaffoldOptimaReadmes(toolWorktree);
-        const tasksDir = optimaTasksDir(toolWorktree);
-        const scrsDir = optimaScrsDir(toolWorktree);
-        if (!fs2.existsSync(tasksDir)) fs2.mkdirSync(tasksDir, { recursive: true });
-        if (!fs2.existsSync(scrsDir)) fs2.mkdirSync(scrsDir, { recursive: true });
-        const currentPath = path2.join(tasksDir, "current.md");
-        const donePath = path2.join(tasksDir, "done.md");
-        const scrsCurrentPath = path2.join(scrsDir, "current.md");
-        const scrsDonePath = path2.join(scrsDir, "done.md");
-        if (!fs2.existsSync(currentPath)) {
-          fs2.writeFileSync(currentPath, "# 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", "utf8");
-        }
-        if (!fs2.existsSync(donePath)) {
-          fs2.writeFileSync(donePath, "# Completed Tasks (Registry)\n\n| Date | Task ID | SCR ID | Commit | Summary |\n| :--- | :--- | :--- | :--- | :--- |\n", "utf8");
-        }
-        if (!fs2.existsSync(scrsCurrentPath)) {
-          fs2.writeFileSync(scrsCurrentPath, "# Current Spec Change Requests (Backlog)\n\n## \u{1F680} Active/Review\n- (None)\n\n## \u{1F4CB} Approved (Ready for Implementation)\n- (None)\n\n## \u{1F4A1} Proposed\n- (None)\n", "utf8");
-        }
-        if (!fs2.existsSync(scrsDonePath)) {
-          fs2.writeFileSync(scrsDonePath, "# Implemented Spec Change Requests\n\n| Date | SCR ID | Title | Related Feature | Task ID |\n| :--- | :--- | :--- | :--- | :--- |\n", "utf8");
-        }
+        ensureOptimaRegistries(toolWorktree);
         const gitignoreResult = ensureOptimaGitignoreRules(toolWorktree);
         const gitignoreNote = gitignoreResult.added.length > 0 ? ` Added ${gitignoreResult.added.length} Optima local/private .gitignore rule(s).` : "";
         const initSummary = `Optima initialized in '${requestedTeamMode}' team mode: .optima/.config/optima.yaml, repo policy/agent folders, registries, and .optima/codemap.yml created.${gitignoreNote}`;
@@ -12046,14 +12619,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 = path2.resolve(safe.worktree, args.summary_path || "");
-        if (!fs2.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
-        const taskPath = args.task_path ? path2.resolve(safe.worktree, args.task_path) : "";
+        const summaryPath = path5.resolve(safe.worktree, args.summary_path || "");
+        if (!fs5.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
+        const taskPath = args.task_path ? path5.resolve(safe.worktree, args.task_path) : "";
         const payload = buildClickUpSummaryPayload({
-          summaryMarkdown: fs2.readFileSync(summaryPath, "utf8"),
-          summaryPath: path2.relative(safe.worktree, summaryPath),
-          taskMarkdown: taskPath && fs2.existsSync(taskPath) ? fs2.readFileSync(taskPath, "utf8") : "",
-          taskPath: taskPath ? path2.relative(safe.worktree, taskPath) : "",
+          summaryMarkdown: fs5.readFileSync(summaryPath, "utf8"),
+          summaryPath: path5.relative(safe.worktree, summaryPath),
+          taskMarkdown: taskPath && fs5.existsSync(taskPath) ? fs5.readFileSync(taskPath, "utf8") : "",
+          taskPath: taskPath ? path5.relative(safe.worktree, taskPath) : "",
           branch: args.branch,
           worktree: args.worktree,
           pr: args.pr
@@ -12132,12 +12705,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 = path2.resolve(safe.worktree, args.markdown_path || "");
-        if (!fs2.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
+        const markdownPath = path5.resolve(safe.worktree, args.markdown_path || "");
+        if (!fs5.existsSync(markdownPath)) return `FAIL: markdown_path not found: ${markdownPath}`;
         const payload = buildClickUpCreateSubtasksPayload({
           parentTaskId: args.parent_task_id,
-          markdown: fs2.readFileSync(markdownPath, "utf8"),
-          sourcePath: path2.relative(safe.worktree, markdownPath),
+          markdown: fs5.readFileSync(markdownPath, "utf8"),
+          sourcePath: path5.relative(safe.worktree, markdownPath),
           parentBranch: args.parent_branch,
           parentTaskType: args.parent_task_type || "Tarea",
           apply: String(args.apply || "").toLowerCase() === "true"
@@ -12169,6 +12742,21 @@ Restart or reload OpenCode manually if the newly scaffolded config or agents are
         return formatValidationResult(res);
       }
     }),
+    optima_repair: tool({
+      description: "Inspect and repair Optima operational errors across config, registries, templates, policies, legacy artifacts, Markdown paths, gitignore rules, and CodeMaps. Dry-run by default; set apply true to mutate safely.",
+      args: {
+        apply: tool.schema.boolean().optional().describe("Set true to apply deterministic Optima metadata repairs. Defaults to false dry-run."),
+        mode: tool.schema.string().optional().describe("Optional mode: 'dry-run' or 'apply'. Dry-run is the default."),
+        team_mode: tool.schema.string().optional().describe("Team mode for a newly created config when missing: mini or full. Defaults to full.")
+      },
+      async execute(args, context) {
+        const safe = safeWorktreeOrFailure(context, worktree);
+        if (!safe.ok) return safe.message;
+        const plan = planOptimaRepair(safe.worktree, args, optimaRepairDependencies());
+        const validationResult = plan.mode === "apply" ? await optima_validate_logic(safe.worktree) : null;
+        return formatRepairResult(plan, validationResult, formatValidationResult);
+      }
+    }),
     optima_start_discussion: tool({
       description: "Start an automatic discussion transcript for this session",
       args: {
@@ -12321,7 +12909,7 @@ Backfilled messages: ${backfilled}`;
         if (!existing) {
           return "FAIL: No active discussion exists for this session.";
         }
-        const discussionPath = path2.join(toolWorktree, existing.transcriptPath);
+        const discussionPath = path5.join(toolWorktree, existing.transcriptPath);
         setDiscussionStatus(discussionPath, "summarizing");
         existing.status = "summarizing";
         saveDiscussionRegistry(toolWorktree, toolRegistry);
@@ -12373,7 +12961,7 @@ Reason: ${err.message}`;
         try {
           const sessionResult = await client.session.create({
             query: { directory: workflowDirectory },
-            body: { title: `Workflow Run: ${path2.basename(workflowTaskPath)}` }
+            body: { title: `Workflow Run: ${path5.basename(workflowTaskPath)}` }
           });
           const sessionId = sessionResult.data.id;
           activeWorkflows.set(sessionId, { pmaSessionId, taskPath: workflowTaskPath, track: workflowTrack, directory: workflowDirectory });
@@ -12502,7 +13090,7 @@ Follow-up: use optima_prompt_workflow with session_id '${sessionId}' to check in
     }
   };
 }
-OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, createClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, scheduleClickUpStartupReconciliation, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
+OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, scheduleClickUpStartupReconciliation, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
 export {
   OptimaPlugin as default
 };