@defend-tech/opencode-optima 0.1.54 → 0.1.56

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;
@@ -9067,7 +9623,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 +9665,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 +9695,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 +9705,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 "";
     }
@@ -9405,9 +9961,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 +9980,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 {
   }
 }
@@ -9830,12 +10386,170 @@ function normalizeOpenCodeSessionMessages(result) {
   if (Array.isArray(data?.items)) return [...data.items];
   return [];
 }
+function clampOpenCodeMessageLimit(limit) {
+  const value = Number(limit);
+  if (!Number.isFinite(value)) return 20;
+  return Math.min(50, Math.max(1, Math.floor(value)));
+}
+function clampOpenCodeSessionText(text = "", maxLength = 12e3) {
+  const value = String(text ?? "");
+  return value.length > maxLength ? value.slice(0, maxLength) : value;
+}
+function hashOpenCodeSessionText(text = "") {
+  return crypto.createHash("sha256").update(String(text ?? "")).digest("hex");
+}
 async function readOpenCodeSessionMessages(client, { sessionId, directory, limit = 20 } = {}) {
   if (typeof client?.session?.messages !== "function") return null;
-  const query = { limit };
+  const query = { limit: clampOpenCodeMessageLimit(limit) };
   if (directory) query.directory = directory;
   return normalizeOpenCodeSessionMessages(await client.session.messages({ path: { id: sessionId }, query }));
 }
+function openCodeResultSummary(result) {
+  const data = result?.data ?? result;
+  return {
+    type: Array.isArray(data) ? "array" : typeof data,
+    id: data?.id || data?.sessionID || data?.sessionId || result?.id || result?.sessionID || result?.sessionId || null,
+    keys: data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data).slice(0, 20) : [],
+    dataKeys: result?.data && typeof result.data === "object" && !Array.isArray(result.data) ? Object.keys(result.data).slice(0, 20) : [],
+    status: result?.status || result?.response?.status || null
+  };
+}
+function normalizeOpenCodeMessageRole(message = {}) {
+  return message.role || message.info?.role || message.author?.role || message.type || "";
+}
+function normalizeOpenCodeMessageAgent(message = {}) {
+  return message.agent || message.info?.agent || message.mode?.agent || message.author?.agent || "";
+}
+function normalizeOpenCodeMessageMode(message = {}) {
+  return message.mode || message.info?.mode || message.metadata?.mode || "";
+}
+function normalizeOpenCodeMessageId(message = {}) {
+  return message.id || message.messageID || message.messageId || message.info?.id || message.data?.id || null;
+}
+function summarizeOpenCodeMessages(messages = [], { snippetLength = 160, maxMessages = 50 } = {}) {
+  const list = Array.isArray(messages) ? messages.slice(0, maxMessages) : [];
+  const safeSnippetLength = Math.min(240, Math.max(20, Number(snippetLength) || 160));
+  return list.map((message, index) => {
+    const text = openCodeMessageText(message).replace(/\s+/g, " ").trim();
+    return {
+      index,
+      id: normalizeOpenCodeMessageId(message),
+      role: normalizeOpenCodeMessageRole(message),
+      agent: normalizeOpenCodeMessageAgent(message),
+      mode: normalizeOpenCodeMessageMode(message),
+      text_length: text.length,
+      text_hash: hashOpenCodeSessionText(text),
+      snippet: text.length > safeSnippetLength ? `${text.slice(0, safeSnippetLength)}...` : text
+    };
+  });
+}
+function promptResultAssistantReturned(result) {
+  const parts = normalizePromptResponseParts(result);
+  const text = extractTextParts(parts);
+  const data = result?.data ?? result;
+  return Boolean(text || data?.role === "assistant" || data?.info?.role === "assistant");
+}
+async function createOpenCodeSessionControl(client, { directory, title, agent } = {}) {
+  if (typeof client?.session?.create !== "function") throw new Error("OpenCode client does not expose session.create.");
+  const body = { title };
+  if (agent) body.agent = agent;
+  const result = await client.session.create({ query: { directory }, body });
+  const sessionId = extractOpenCodeSessionId(result);
+  if (!sessionId) throw new Error("OpenCode session create response did not include a session id.");
+  return {
+    ok: true,
+    session_id: sessionId,
+    title,
+    directory,
+    agent: agent || null,
+    result_summary: openCodeResultSummary(result)
+  };
+}
+async function promptOpenCodeSessionControl(client, { sessionId, directory, text, agent, omitAgent = false, requireReadable = true } = {}) {
+  if (typeof client?.session?.prompt !== "function") throw new Error("OpenCode client does not expose session.prompt.");
+  if (requireReadable) await assertOpenCodeSessionReadableForDirectory(client, { sessionId, directory });
+  const safeText = clampOpenCodeSessionText(text);
+  const body = { parts: [{ type: "text", text: safeText }] };
+  if (!omitAgent && agent) body.agent = agent;
+  const result = await client.session.prompt({ path: { id: sessionId }, query: { directory }, body });
+  return {
+    ok: true,
+    session_id: sessionId,
+    directory,
+    agent: omitAgent ? null : agent || null,
+    omit_agent: Boolean(omitAgent),
+    text_length: safeText.length,
+    text_truncated: String(text ?? "").length > safeText.length,
+    text_hash: hashOpenCodeSessionText(safeText),
+    assistant_returned: promptResultAssistantReturned(result),
+    returned_parts_count: normalizePromptResponseParts(result).length,
+    result_summary: openCodeResultSummary(result)
+  };
+}
+async function assertOpenCodeSessionReadableForDirectory(client, { sessionId, directory } = {}) {
+  try {
+    await readOpenCodeSessionMessages(client, { sessionId, directory, limit: 1 });
+    return true;
+  } catch (error) {
+    throw new Error(`OpenCode session '${sessionId}' is not readable for the requested safe directory.`);
+  }
+}
+async function readOpenCodeSessionControl(client, { sessionId, directory, limit = 20 } = {}) {
+  const boundedLimit = clampOpenCodeMessageLimit(limit);
+  const messages = await readOpenCodeSessionMessages(client, { sessionId, directory, limit: boundedLimit });
+  if (!messages) throw new Error("OpenCode client does not expose session.messages.");
+  return {
+    ok: true,
+    session_id: sessionId,
+    directory: directory || null,
+    limit: boundedLimit,
+    count: messages.length,
+    messages: summarizeOpenCodeMessages(messages)
+  };
+}
+async function probeOpenCodeSessionControl(client, { directory, agent, omitAgentOnPrompt = false, text = "" } = {}) {
+  const requestedMarker = text || `optima-session-probe-${crypto.randomUUID()}`;
+  const marker = clampOpenCodeSessionText(requestedMarker);
+  const create = await createOpenCodeSessionControl(client, {
+    directory,
+    title: `Optima session probe ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    agent
+  });
+  const prompt = await promptOpenCodeSessionControl(client, {
+    sessionId: create.session_id,
+    directory,
+    text: marker,
+    agent,
+    omitAgent: omitAgentOnPrompt,
+    requireReadable: false
+  });
+  const rawMessages = await readOpenCodeSessionMessages(client, { sessionId: create.session_id, directory, limit: 50 });
+  if (!rawMessages) throw new Error("OpenCode client does not expose session.messages.");
+  const fullMessageText = rawMessages.map(openCodeMessageText).join("\n");
+  const messages = {
+    ok: true,
+    session_id: create.session_id,
+    directory,
+    limit: 50,
+    count: rawMessages.length,
+    messages: summarizeOpenCodeMessages(rawMessages)
+  };
+  return {
+    ok: true,
+    session_id: create.session_id,
+    directory,
+    agent: agent || null,
+    omit_agent_on_prompt: Boolean(omitAgentOnPrompt),
+    marker_length: marker.length,
+    marker_truncated: requestedMarker.length > marker.length,
+    marker_hash: hashOpenCodeSessionText(marker),
+    marker_visible: fullMessageText.includes(marker),
+    assistant_visible: rawMessages.some((message) => normalizeLooseToken(normalizeOpenCodeMessageRole(message)) === "assistant" || Boolean(normalizeOpenCodeMessageAgent(message) && openCodeMessageText(message))),
+    create,
+    prompt,
+    messages
+  };
+}
 function openCodeMessageText(message) {
   const parts = [message?.text, message?.content, message?.message, message?.body?.text, message?.data?.text];
   const partList = Array.isArray(message?.parts) ? message.parts : Array.isArray(message?.body?.parts) ? message.body.parts : [];
@@ -9986,9 +10700,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) {
@@ -10017,7 +10731,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();
@@ -10116,13 +10830,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 || ""));
@@ -10138,11 +10852,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 {
   }
@@ -10498,7 +11212,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 || [],
@@ -10595,17 +11309,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,
@@ -10621,76 +11335,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;
@@ -10699,59 +11417,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 [];
@@ -10761,67 +11479,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 };
@@ -10836,7 +11493,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 };
   }
@@ -10853,10 +11510,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,
@@ -10881,11 +11538,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)]))
@@ -10898,34 +11555,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,
@@ -10941,37 +11598,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);
 }
@@ -11036,18 +11693,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}` }
   });
@@ -11147,30 +11804,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];
@@ -11178,7 +11835,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) {
@@ -11217,13 +11874,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) {
@@ -11232,9 +11889,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 };
@@ -11245,13 +11902,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.",
@@ -11262,19 +11919,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 `---
@@ -11348,19 +12017,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",
@@ -11454,6 +12162,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: {
@@ -11469,18 +12209,26 @@ 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;
   return validation?.complete === true && validation?.ok !== false && isSameOrNestedPath(worktree, validation.config?.basePath);
 }
+function resolveSessionToolDirectory({ requestedDirectory, context, pluginWorktree, clickUpWebhookValidation } = {}) {
+  const safe = safeWorktreeOrFailure(context, pluginWorktree);
+  if (!safe.ok) return { ok: false, error: safe.message };
+  const requested = String(requestedDirectory || "").trim() ? 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: path5.resolve(clickUpBasePath) };
+  }
+  return {
+    ok: false,
+    error: `Directory '${requested}' is outside the safe worktree '${safe.worktree}' and configured ClickUp base path.`
+  };
+}
 function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, options = {}) {
   const optimaActive = repoCfg && repoCfg.enabled === true;
   const clickUpWebhookActive = shouldRegisterWorkflowProductManager(options, worktree);
@@ -11508,8 +12256,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;
@@ -11518,7 +12266,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}
 
@@ -11571,14 +12319,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) {
@@ -11602,9 +12350,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);
     }
@@ -11711,54 +12459,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}`;
@@ -11767,6 +12477,100 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
 Restart or reload OpenCode manually if the newly scaffolded config or agents are not visible in this session. Optima did not dispose or reload the active OpenCode instance automatically to avoid aborting the current session.`;
       }
     }),
+    optima_session_create: tool({
+      description: "Create an OpenCode session through the installed structured SDK shape",
+      args: {
+        directory: tool.schema.string().describe("Project directory for the OpenCode session"),
+        title: tool.schema.string().describe("Session title"),
+        agent: tool.schema.string().describe("Optional agent id for session creation")
+      },
+      async execute(args, context) {
+        try {
+          const directory = resolveSessionToolDirectory({ requestedDirectory: args.directory, context, pluginWorktree: worktree, clickUpWebhookValidation });
+          if (!directory.ok) return JSON.stringify({ ok: false, error: directory.error }, null, 2);
+          const result = await createOpenCodeSessionControl(input.client, {
+            directory: directory.directory,
+            title: args.title,
+            agent: args.agent
+          });
+          return JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message }, null, 2);
+        }
+      }
+    }),
+    optima_session_prompt: tool({
+      description: "Prompt an existing OpenCode session through the installed structured SDK shape",
+      args: {
+        session_id: tool.schema.string().describe("OpenCode session id"),
+        directory: tool.schema.string().describe("Project directory for the OpenCode session"),
+        text: tool.schema.string().describe("Text prompt to send"),
+        agent: tool.schema.string().describe("Optional agent id for the prompt body"),
+        omit_agent: tool.schema.string().describe("Set to 'true' to omit agent from the prompt body")
+      },
+      async execute(args, context) {
+        try {
+          const directory = resolveSessionToolDirectory({ requestedDirectory: args.directory, context, pluginWorktree: worktree, clickUpWebhookValidation });
+          if (!directory.ok) return JSON.stringify({ ok: false, error: directory.error }, null, 2);
+          const result = await promptOpenCodeSessionControl(input.client, {
+            sessionId: args.session_id,
+            directory: directory.directory,
+            text: args.text,
+            agent: args.agent,
+            omitAgent: String(args.omit_agent || "").toLowerCase() === "true"
+          });
+          return JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message }, null, 2);
+        }
+      }
+    }),
+    optima_session_messages: tool({
+      description: "Read and summarize OpenCode session messages through the installed structured SDK shape",
+      args: {
+        session_id: tool.schema.string().describe("OpenCode session id"),
+        directory: tool.schema.string().describe("Optional project directory for the OpenCode session"),
+        limit: tool.schema.number().describe("Optional message limit")
+      },
+      async execute(args, context) {
+        try {
+          const directory = resolveSessionToolDirectory({ requestedDirectory: args.directory, context, pluginWorktree: worktree, clickUpWebhookValidation });
+          if (!directory.ok) return JSON.stringify({ ok: false, error: directory.error }, null, 2);
+          const result = await readOpenCodeSessionControl(input.client, {
+            sessionId: args.session_id,
+            directory: directory.directory,
+            limit: args.limit
+          });
+          return JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message }, null, 2);
+        }
+      }
+    }),
+    optima_session_probe: tool({
+      description: "Create, prompt, and read an OpenCode session without touching ClickUp state",
+      args: {
+        directory: tool.schema.string().describe("Project directory for the OpenCode session"),
+        agent: tool.schema.string().describe("Optional agent id to probe"),
+        omit_agent_on_prompt: tool.schema.string().describe("Set to 'true' to omit agent from the prompt body"),
+        text: tool.schema.string().describe("Optional marker text to send")
+      },
+      async execute(args, context) {
+        try {
+          const directory = resolveSessionToolDirectory({ requestedDirectory: args.directory, context, pluginWorktree: worktree, clickUpWebhookValidation });
+          if (!directory.ok) return JSON.stringify({ ok: false, error: directory.error }, null, 2);
+          const result = await probeOpenCodeSessionControl(input.client, {
+            directory: directory.directory,
+            agent: args.agent,
+            omitAgentOnPrompt: String(args.omit_agent_on_prompt || "").toLowerCase() === "true",
+            text: args.text
+          });
+          return JSON.stringify(result, null, 2);
+        } catch (error) {
+          return JSON.stringify({ ok: false, error: error.message }, null, 2);
+        }
+      }
+    }),
     optima_clickup_sync_summary: tool({
       description: "Generate a dry-run ClickUp summary/comment payload from Optima Markdown task and evidence artifacts",
       args: {
@@ -11779,14 +12583,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
@@ -11865,12 +12669,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"
@@ -11902,6 +12706,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: {
@@ -12054,7 +12873,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);
@@ -12106,7 +12925,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 });
@@ -12235,7 +13054,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, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionMessages, reconcileClickUpStartup, scheduleClickUpStartupReconciliation, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, 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, 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
 };