@defend-tech/opencode-optima 0.1.67 → 0.1.69

package/dist/sanitize_cli.js

@@ -109,17 +109,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path7) {
-      const ctrl = callVisitor(key, node, visitor, path7);
+    function visit_(key, node, visitor, path8) {
+      const ctrl = callVisitor(key, node, visitor, path8);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visit_(key, ctrl, visitor, path7);
+        replaceNode(key, path8, ctrl);
+        return visit_(key, ctrl, visitor, path8);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path8 = Object.freeze(path8.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path7);
+            const ci = visit_(i, node.items[i], visitor, path8);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -130,13 +130,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = visit_("key", node.key, visitor, path7);
+          path8 = Object.freeze(path8.concat(node));
+          const ck = visit_("key", node.key, visitor, path8);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path7);
+          const cv = visit_("value", node.value, visitor, path8);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -157,17 +157,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path7) {
-      const ctrl = await callVisitor(key, node, visitor, path7);
+    async function visitAsync_(key, node, visitor, path8) {
+      const ctrl = await callVisitor(key, node, visitor, path8);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visitAsync_(key, ctrl, visitor, path7);
+        replaceNode(key, path8, ctrl);
+        return visitAsync_(key, ctrl, visitor, path8);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path8 = Object.freeze(path8.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path7);
+            const ci = await visitAsync_(i, node.items[i], visitor, path8);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -178,13 +178,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path7);
+          path8 = Object.freeze(path8.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path8);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path7);
+          const cv = await visitAsync_("value", node.value, visitor, path8);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -211,23 +211,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path7) {
+    function callVisitor(key, node, visitor, path8) {
       if (typeof visitor === "function")
-        return visitor(key, node, path7);
+        return visitor(key, node, path8);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path7);
+        return visitor.Map?.(key, node, path8);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path7);
+        return visitor.Seq?.(key, node, path8);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path7);
+        return visitor.Pair?.(key, node, path8);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path7);
+        return visitor.Scalar?.(key, node, path8);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path7);
+        return visitor.Alias?.(key, node, path8);
       return void 0;
     }
-    function replaceNode(key, path7, node) {
-      const parent = path7[path7.length - 1];
+    function replaceNode(key, path8, node) {
+      const parent = path8[path8.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -835,10 +835,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path7, value) {
+    function collectionFromPath(schema, path8, value) {
       let v = value;
-      for (let i = path7.length - 1; i >= 0; --i) {
-        const k = path7[i];
+      for (let i = path8.length - 1; i >= 0; --i) {
+        const k = path8[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -857,7 +857,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path7) => path7 == null || typeof path7 === "object" && !!path7[Symbol.iterator]().next().done;
+    var isEmptyPath = (path8) => path8 == null || typeof path8 === "object" && !!path8[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -887,11 +887,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path7, value) {
-        if (isEmptyPath(path7))
+      addIn(path8, value) {
+        if (isEmptyPath(path8))
           this.add(value);
         else {
-          const [key, ...rest] = path7;
+          const [key, ...rest] = path8;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -905,8 +905,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        const [key, ...rest] = path7;
+      deleteIn(path8) {
+        const [key, ...rest] = path8;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -920,8 +920,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        const [key, ...rest] = path7;
+      getIn(path8, keepScalar) {
+        const [key, ...rest] = path8;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -939,8 +939,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path7) {
-        const [key, ...rest] = path7;
+      hasIn(path8) {
+        const [key, ...rest] = path8;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -950,8 +950,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        const [key, ...rest] = path7;
+      setIn(path8, value) {
+        const [key, ...rest] = path8;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3455,9 +3455,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path7, value) {
+      addIn(path8, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path7, value);
+          this.contents.addIn(path8, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3532,14 +3532,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        if (Collection.isEmptyPath(path7)) {
+      deleteIn(path8) {
+        if (Collection.isEmptyPath(path8)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path7) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path8) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3554,10 +3554,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        if (Collection.isEmptyPath(path7))
+      getIn(path8, keepScalar) {
+        if (Collection.isEmptyPath(path8))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path7, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path8, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3568,10 +3568,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path7) {
-        if (Collection.isEmptyPath(path7))
+      hasIn(path8) {
+        if (Collection.isEmptyPath(path8))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path7) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path8) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3588,13 +3588,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        if (Collection.isEmptyPath(path7)) {
+      setIn(path8, value) {
+        if (Collection.isEmptyPath(path8)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path8), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path7, value);
+          this.contents.setIn(path8, value);
         }
       }
       /**
@@ -5546,9 +5546,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path7) => {
+    visit.itemAtPath = (cst, path8) => {
       let item = cst;
-      for (const [field, index] of path7) {
+      for (const [field, index] of path8) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5557,23 +5557,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path7) => {
-      const parent = visit.itemAtPath(cst, path7.slice(0, -1));
-      const field = path7[path7.length - 1][0];
+    visit.parentCollection = (cst, path8) => {
+      const parent = visit.itemAtPath(cst, path8.slice(0, -1));
+      const field = path8[path8.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path7, item, visitor) {
-      let ctrl = visitor(item, path7);
+    function _visit(path8, item, visitor) {
+      let ctrl = visitor(item, path8);
       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(path7.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path8.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5584,10 +5584,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path7);
+            ctrl = ctrl(item, path8);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path7) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path8) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7551,17 +7551,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path7, originalPath, doThrow) => {
-      if (!isString(path7)) {
+    var checkPath = (path8, originalPath, doThrow) => {
+      if (!isString(path8)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path7) {
+      if (!path8) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path7)) {
+      if (checkPath.isNotRelative(path8)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -7570,7 +7570,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7629,7 +7629,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path7, checkUnignored) {
+      _testOne(path8, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -7637,7 +7637,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path7);
+          const matched = rule.regex.test(path8);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7650,24 +7650,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path7 = originalPath && checkPath.convert(originalPath);
+        const path8 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path7,
+          path8,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path7, cache, checkUnignored, slices);
+        return this._t(path8, cache, checkUnignored, slices);
       }
-      _t(path7, cache, checkUnignored, slices) {
-        if (path7 in cache) {
-          return cache[path7];
+      _t(path8, cache, checkUnignored, slices) {
+        if (path8 in cache) {
+          return cache[path8];
         }
         if (!slices) {
-          slices = path7.split(SLASH);
+          slices = path8.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path7] = this._testOne(path7, checkUnignored);
+          return cache[path8] = this._testOne(path8, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7675,24 +7675,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path7] = parent.ignored ? parent : this._testOne(path7, checkUnignored);
+        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
       }
-      ignores(path7) {
-        return this._test(path7, this._ignoreCache, false).ignored;
+      ignores(path8) {
+        return this._test(path8, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path7) => !this.ignores(path7);
+        return (path8) => !this.ignores(path8);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path7) {
-        return this._test(path7, this._testCache, true);
+      test(path8) {
+        return this._test(path8, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7703,7 +7703,7 @@ 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 = (path7) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+      checkPath.isNotRelative = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
     }
   }
 });
@@ -7711,7 +7711,7 @@ var require_ignore = __commonJS({
 // src/sanitize_cli.js
 import fs6 from "node:fs";
 import os2 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 
 // src/index.js
@@ -7721,8 +7721,7 @@ import crypto from "node:crypto";
 import fs5 from "node:fs";
 import http from "node:http";
 import os from "node:os";
-import path5 from "node:path";
-import { fileURLToPath } from "node:url";
+import path6 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/git_utils.js
@@ -8493,7 +8492,9 @@ async function optima_validate_logic(worktree) {
   };
 }
 
-// src/index.js
+// src/constants.js
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
 var PKG_ROOT = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "..");
 var BUNDLE_ASSETS_DIR = path5.join(PKG_ROOT, "assets");
 var BUNDLE_AGENTS_DIR = path5.join(BUNDLE_ASSETS_DIR, "agents");
@@ -8534,6 +8535,8 @@ var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
 var CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT = 50;
 var CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT = 100;
 var CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS = 3e4;
+var CLICKUP_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS = 6 * 60 * 60 * 1e3;
+var CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS = 5 * 60 * 1e3;
 var CLICKUP_WORKTREE_FAILURE_COMMENT_DEDUPE_MS = 10 * 60 * 1e3;
 var CLICKUP_WEBHOOK_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "info", "verbose"]);
 var CLICKUP_WEBHOOK_REDACTED = "[REDACTED]";
@@ -8622,20 +8625,22 @@ var REPO_LOCAL_POLICIES_README = [
   "Only files in `.optima/policies/` affect runtime prompt behavior.",
   ""
 ].join("\n");
+var CLICKUP_WEBHOOK_CLEANUP_TIMEOUT_MS = 8e3;
+var CLICKUP_WEBHOOK_SIGNAL_STATE = Symbol.for("opencode-optima.clickup-webhook.signal-state");
+
+// src/index.js
 var activeWorkflows = /* @__PURE__ */ new Map();
 var activeClickUpWebhookListeners = /* @__PURE__ */ new Map();
 var activeClickUpWebhookLifecycleRegistry = /* @__PURE__ */ new Map();
-var CLICKUP_WEBHOOK_CLEANUP_TIMEOUT_MS = 8e3;
-var CLICKUP_WEBHOOK_SIGNAL_STATE = Symbol.for("opencode-optima.clickup-webhook.signal-state");
 var activeClickUpTaskRoutes = /* @__PURE__ */ new Map();
 function isRootDirectory(candidate) {
-  const resolved = path5.resolve(candidate);
-  return resolved === path5.parse(resolved).root;
+  const resolved = path6.resolve(candidate);
+  return resolved === path6.parse(resolved).root;
 }
 function isSafeWritableDirectory(candidate) {
   if (typeof candidate !== "string" || !candidate.trim()) return false;
-  if (!path5.isAbsolute(candidate)) return false;
-  const resolved = path5.resolve(candidate);
+  if (!path6.isAbsolute(candidate)) return false;
+  const resolved = path6.resolve(candidate);
   if (isRootDirectory(resolved)) return false;
   try {
     const stat = fs5.statSync(resolved);
@@ -8656,7 +8661,7 @@ function resolveSafeWorktree(context = {}, pluginWorktree = null) {
   ];
   for (const candidate of candidates) {
     if (typeof candidate !== "string" || !candidate.trim()) continue;
-    const resolved = path5.resolve(candidate);
+    const resolved = path6.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   throw new Error(SAFE_WORKTREE_FAILURE);
@@ -8671,13 +8676,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 = path5.resolve(candidate);
+    const resolved = path6.resolve(candidate);
     if (isSafeWritableDirectory(resolved)) return resolved;
   }
   return null;
 }
 function isGitRepository(worktree) {
-  return fs5.existsSync(path5.join(worktree, ".git"));
+  return fs5.existsSync(path6.join(worktree, ".git"));
 }
 function normalizeLooseToken(value) {
   return String(value ?? "").trim().normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -9172,7 +9177,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 path5.join(path5.dirname(root), `${path5.basename(root)}-${branch.replace(/\//g, "-")}`);
+  return path6.join(path6.dirname(root), `${path6.basename(root)}-${branch.replace(/\//g, "-")}`);
 }
 function clickUpCustomFieldValue(task = {}, names = []) {
   const fields = Array.isArray(task.custom_fields) ? task.custom_fields : [];
@@ -9196,12 +9201,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 || !path5.isAbsolute(existingWorktree) || !fs5.existsSync(existingWorktree)) return null;
+  if (!existingWorktree || !path6.isAbsolute(existingWorktree) || !fs5.existsSync(existingWorktree)) return null;
   try {
     const stat = fs5.statSync(existingWorktree);
     if (!stat.isDirectory()) return null;
     if (branch && existingBranch && existingBranch !== branch) return null;
-    return { branch: existingBranch || branch, worktree: path5.resolve(existingWorktree), reused: true };
+    return { branch: existingBranch || branch, worktree: path6.resolve(existingWorktree), reused: true };
   } catch {
     return null;
   }
@@ -9287,17 +9292,17 @@ function openChamberEntryBranch(entry) {
   return String(entry?.branch || entry?.branchName || entry?.branch_name || entry?.worktree?.branch || "").replace(/^refs\/heads\//, "");
 }
 function openChamberListIncludesDirectory(list, directory) {
-  const resolved = path5.resolve(directory);
+  const resolved = path6.resolve(directory);
   return normalizeOpenChamberCollection(list).some((entry) => {
     const entryDirectory = openChamberEntryDirectory(entry);
-    return entryDirectory && path5.resolve(entryDirectory) === resolved;
+    return entryDirectory && path6.resolve(entryDirectory) === resolved;
   });
 }
 function openChamberListIncludesBranch(list, directory, branch) {
-  const resolved = path5.resolve(directory);
+  const resolved = path6.resolve(directory);
   return normalizeOpenChamberCollection(list).some((entry) => {
     const entryDirectory = openChamberEntryDirectory(entry);
-    if (!entryDirectory || path5.resolve(entryDirectory) !== resolved) return false;
+    if (!entryDirectory || path6.resolve(entryDirectory) !== resolved) return false;
     const entryBranch = openChamberEntryBranch(entry);
     return !entryBranch || entryBranch === branch;
   });
@@ -9305,8 +9310,8 @@ function openChamberListIncludesBranch(list, directory, branch) {
 async function findOpenChamberProject({ opencodeBaseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
   const projects = await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: "/project", directory: baseWorktree, fetchImpl });
   if (!Array.isArray(projects)) return null;
-  const resolvedBase = path5.resolve(baseWorktree);
-  return projects.find((project) => path5.resolve(String(project?.worktree || project?.path || "")) === resolvedBase) || null;
+  const resolvedBase = path6.resolve(baseWorktree);
+  return projects.find((project) => path6.resolve(String(project?.worktree || project?.path || "")) === resolvedBase) || null;
 }
 async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, projectId, fetchImpl = globalThis.fetch } = {}) {
   if (!projectId) return { refreshed: false, reason: "project_id_unavailable" };
@@ -9361,18 +9366,18 @@ async function createOpenChamberClickUpWorktree({ openchamberBaseUrl, baseUrl, b
   }
   const createdDirectory = openChamberEntryDirectory(created);
   const createdBranch = openChamberEntryBranch(created);
-  if (!createdDirectory || !path5.isAbsolute(createdDirectory)) {
+  if (!createdDirectory || !path6.isAbsolute(createdDirectory)) {
     throw new Error(`OpenChamber did not return an absolute worktree path for ${branch}.`);
   }
   if (createdBranch !== branch) {
     throw new Error(`OpenChamber created unexpected branch ${createdBranch || "<unknown>"}; expected ${branch}.`);
   }
   const verified = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath: createdDirectory, branch, fetchImpl });
-  return { created, worktree: path5.resolve(createdDirectory), branch: createdBranch, verified };
+  return { created, worktree: path6.resolve(createdDirectory), branch: createdBranch, verified };
 }
 async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
   const visibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: openchamberBaseUrl || baseUrl, opencodeBaseUrl: opencodeBaseUrl || baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
-  return { branch, worktree: path5.resolve(worktreePath), reused: true, provider: "openchamber", openChamber: { source, visibility } };
+  return { branch, worktree: path6.resolve(worktreePath), reused: true, provider: "openchamber", openChamber: { source, visibility } };
 }
 async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, openchamberBaseUrl = "", opencodeBaseUrl = "", baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
   const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
@@ -9435,10 +9440,10 @@ function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tare
   const existing = safeExistingClickUpWorktree({ metadata: existingMetadata, branch });
   if (existing) return { ...existing, branch, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev" };
   const worktreePath = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
-  if (fs5.existsSync(worktreePath)) return { branch, worktree: path5.resolve(worktreePath), reused: true, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev" };
+  if (fs5.existsSync(worktreePath)) return { branch, worktree: path6.resolve(worktreePath), reused: true, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev" };
   if (allowNonGitFallback) {
     fs5.mkdirSync(worktreePath, { recursive: true });
-    return { branch, worktree: path5.resolve(worktreePath), reused: false, fallback: "non_git", parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", startPoint: parentBranch || "dev" };
+    return { branch, worktree: path6.resolve(worktreePath), reused: false, fallback: "non_git", parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", startPoint: parentBranch || "dev" };
   }
   let parentBootstrap = null;
   if (isSubtask) {
@@ -9447,14 +9452,14 @@ function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tare
       const parentStartPoint = resolveClickUpDevStartPoint(baseWorktree, runGitFn);
       const parentBranchExists = clickUpGitRefExists(baseWorktree, parentBranch, runGitFn);
       addClickUpWorktreeForBranch({ baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, runGitFn });
-      parentBootstrap = { branch: parentBranch, worktree: path5.resolve(parentWorktree), startPoint: parentBranchExists ? parentBranch : parentStartPoint, reused: parentBranchExists };
+      parentBootstrap = { branch: parentBranch, worktree: path6.resolve(parentWorktree), startPoint: parentBranchExists ? parentBranch : parentStartPoint, reused: parentBranchExists };
     } else {
-      parentBootstrap = { branch: parentBranch, worktree: path5.resolve(parentWorktree), reused: true };
+      parentBootstrap = { branch: parentBranch, worktree: path6.resolve(parentWorktree), reused: true };
     }
   }
   const startPoint = isSubtask ? parentBranch : resolveClickUpDevStartPoint(baseWorktree, runGitFn);
   addClickUpWorktreeForBranch({ baseWorktree, branch, worktreePath, startPoint, runGitFn });
-  return { branch, worktree: path5.resolve(worktreePath), reused: false, startPoint, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", parentBootstrap: parentBootstrap || void 0 };
+  return { branch, worktree: path6.resolve(worktreePath), reused: false, startPoint, parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", parentBootstrap: parentBootstrap || void 0 };
 }
 function normalizeClickUpDefinitionDocParent(parent = {}) {
   const docId = String(parent.doc_id || parent.docId || CLICKUP_DEFINITION_DOC_PARENT.doc_id).trim();
@@ -9604,7 +9609,7 @@ function buildClickUpTransitionPayload({ fromStatus, toStatus, validationPassed
 }
 function ensureOptimaGitignoreRules(worktree) {
   if (!isGitRepository(worktree)) return { touched: false, added: [] };
-  const gitignorePath = path5.join(worktree, ".gitignore");
+  const gitignorePath = path6.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));
@@ -9620,40 +9625,40 @@ function ensureOptimaGitignoreRules(worktree) {
   return { touched: true, added: missingRules };
 }
 function optimaDir(worktree) {
-  return path5.join(worktree, OPTIMA_DIRNAME);
+  return path6.join(worktree, OPTIMA_DIRNAME);
 }
 function optimaLocalConfigDir(worktree) {
-  return path5.join(optimaDir(worktree), ".config");
+  return path6.join(optimaDir(worktree), ".config");
 }
 function optimaConfigDir(worktree) {
   return optimaLocalConfigDir(worktree);
 }
 function optimaCodemapPath(worktree) {
-  return path5.join(optimaDir(worktree), "codemap.yml");
+  return path6.join(optimaDir(worktree), "codemap.yml");
 }
 function optimaTasksDir(worktree) {
-  return path5.join(optimaDir(worktree), "tasks");
+  return path6.join(optimaDir(worktree), "tasks");
 }
 function optimaEvidencesDir(worktree) {
-  return path5.join(optimaDir(worktree), "evidences");
+  return path6.join(optimaDir(worktree), "evidences");
 }
 function optimaScrsDir(worktree) {
-  return path5.join(optimaDir(worktree), "docs", "scrs");
+  return path6.join(optimaDir(worktree), "docs", "scrs");
 }
 function legacyNomadworkDir(worktree) {
-  return path5.join(worktree, LEGACY_NOMADWORK_DIRNAME);
+  return path6.join(worktree, LEGACY_NOMADWORK_DIRNAME);
 }
 function legacyNomadworksDir(worktree) {
-  return path5.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
+  return path6.join(worktree, LEGACY_NOMADWORKS_DIRNAME);
 }
 function legacyOrbitaDir(worktree) {
-  return path5.join(worktree, LEGACY_ORBITA_DIRNAME);
+  return path6.join(worktree, LEGACY_ORBITA_DIRNAME);
 }
 function legacyStaticEngDir(worktree) {
-  return path5.join(worktree, LEGACY_STATICENG_DIRNAME);
+  return path6.join(worktree, LEGACY_STATICENG_DIRNAME);
 }
 function repoConfigPath(worktree) {
-  return path5.join(optimaConfigDir(worktree), "optima.yaml");
+  return path6.join(optimaConfigDir(worktree), "optima.yaml");
 }
 function normalizeLegacyDiscussionEntry(entry) {
   if (!entry || typeof entry !== "object") return entry;
@@ -9666,25 +9671,25 @@ function normalizeLegacyDiscussionEntry(entry) {
   return next;
 }
 function repoPoliciesDir(worktree) {
-  return path5.join(optimaDir(worktree), "policies");
+  return path6.join(optimaDir(worktree), "policies");
 }
 function generatedPoliciesDir(worktree) {
-  return path5.join(optimaLocalConfigDir(worktree), "generated", "policies");
+  return path6.join(optimaLocalConfigDir(worktree), "generated", "policies");
 }
 function generatedAgentsDir(worktree) {
-  return path5.join(optimaLocalConfigDir(worktree), "generated", "agents");
+  return path6.join(optimaLocalConfigDir(worktree), "generated", "agents");
 }
 function repoAgentsDir(worktree) {
-  return path5.join(optimaDir(worktree), "agents");
+  return path6.join(optimaDir(worktree), "agents");
 }
 function repoAgentAdditionsDir(worktree) {
-  return path5.join(optimaDir(worktree), "agent-additions");
+  return path6.join(optimaDir(worktree), "agent-additions");
 }
 function legacyRepoAgentsDir(worktree) {
-  return path5.join(legacyNomadworksDir(worktree), "agents");
+  return path6.join(legacyNomadworksDir(worktree), "agents");
 }
 function runtimeDiscussionRegistryPath(worktree) {
-  return path5.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
+  return path6.join(optimaLocalConfigDir(worktree), "runtime", "discussions.json");
 }
 function resolveConfigPath(worktree) {
   return repoConfigPath(worktree);
@@ -9727,32 +9732,32 @@ function mergeClickUpAgentMetadata(existing, update = {}) {
   return JSON.stringify(sortJsonValue(merged), null, 2);
 }
 function optimaRuntimeDir(worktree) {
-  return path5.join(optimaLocalConfigDir(worktree), "runtime");
+  return path6.join(optimaLocalConfigDir(worktree), "runtime");
 }
 function clickUpWebhookStatePath(worktree) {
-  return path5.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
+  return path6.join(optimaRuntimeDir(worktree), "clickup-webhook.json");
 }
 function clickUpCommentLedgerPath(worktree) {
-  return path5.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
+  return path6.join(optimaRuntimeDir(worktree), "clickup-comment-ledger.jsonl");
 }
 function clickUpWebhookLogPath(worktree) {
-  return path5.join(optimaRuntimeDir(worktree), "clickup-webhook.log.jsonl");
+  return path6.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 && 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");
+  const dataHome = process.env.XDG_DATA_HOME && path6.isAbsolute(process.env.XDG_DATA_HOME) ? process.env.XDG_DATA_HOME : path6.join(os.homedir(), ".local", "share", "opencode");
+  return path6.join(dataHome, "opencode-optima");
 }
 function clickUpWebhookAuditLogPath(at = /* @__PURE__ */ new Date(), logDir = clickUpWebhookAuditLogDir()) {
-  return path5.join(logDir, `clickup-webhook-${at.toISOString().slice(0, 10)}.jsonl`);
+  return path6.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 path5.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
+  return path6.join(logDir, "requests", `clickup-webhook-${stamp}-${shortId}.json`);
 }
 function findOptimaPluginTupleOptions(pluginEntries = []) {
   if (!Array.isArray(pluginEntries)) return null;
@@ -9814,6 +9819,10 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
       startupReconciliationDelayMs: normalizeNonNegativeInteger(
         opencode.startup_reconciliation_delay_ms ?? opencode.startupReconciliationDelayMs ?? raw.startup_reconciliation_delay_ms ?? raw.startupReconciliationDelayMs,
         CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS
+      ),
+      assignmentWatchdogIntervalMs: normalizeNonNegativeInteger(
+        opencode.assignment_watchdog_interval_ms ?? opencode.assignmentWatchdogIntervalMs ?? raw.assignment_watchdog_interval_ms ?? raw.assignmentWatchdogIntervalMs,
+        CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS
       )
     },
     openchamber: {
@@ -9847,7 +9856,7 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
   };
   const errors = [];
   if (!config.enabled) errors.push("clickup.enabled must be true");
-  if (!config.basePath || !path5.isAbsolute(config.basePath)) errors.push("clickup.base_path must be an absolute path");
+  if (!config.basePath || !path6.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");
@@ -9905,7 +9914,7 @@ function readClickUpWebhookState(worktree, config = null) {
 }
 function writeClickUpWebhookState(worktree, state, config = null) {
   const statePath = clickUpWebhookStatePath(worktree);
-  fs5.mkdirSync(path5.dirname(statePath), { recursive: true, mode: 448 });
+  fs5.mkdirSync(path6.dirname(statePath), { recursive: true, mode: 448 });
   const next = sanitizeClickUpWebhookState(state, config);
   fs5.writeFileSync(statePath, `${JSON.stringify(next, null, 2)}
 `, { encoding: "utf8", mode: 384 });
@@ -9926,7 +9935,7 @@ function isClickUpWebhookStateActive(state, config) {
 function expandHomePath(value = "") {
   const input = String(value || "").trim();
   if (input === "~") return os.homedir();
-  if (input.startsWith("~/")) return path5.join(os.homedir(), input.slice(2));
+  if (input.startsWith("~/")) return path6.join(os.homedir(), input.slice(2));
   return input;
 }
 function resolveSecretReference(value = "") {
@@ -10302,7 +10311,7 @@ function readClickUpCommentLedger(ledgerPath) {
 }
 function appendClickUpCommentLedgerEntry(ledgerPath, entry = {}) {
   if (!ledgerPath || !entry.key) return;
-  fs5.mkdirSync(path5.dirname(ledgerPath), { recursive: true, mode: 448 });
+  fs5.mkdirSync(path6.dirname(ledgerPath), { recursive: true, mode: 448 });
   fs5.appendFileSync(ledgerPath, `${JSON.stringify(entry)}
 `, { encoding: "utf8", mode: 384 });
   try {
@@ -10779,17 +10788,87 @@ function openCodeResultSummary(result) {
     status: result?.status || result?.response?.status || null
   };
 }
+function openCodeMessagePayload(message = {}) {
+  if (!isPlainObject(message)) return {};
+  const rawData = message.data;
+  if (isPlainObject(rawData)) {
+    return {
+      ...rawData,
+      id: rawData.id || message.id,
+      time_created: rawData.time_created ?? message.time_created,
+      time_updated: rawData.time_updated ?? message.time_updated
+    };
+  }
+  if (typeof rawData === "string" && rawData.trim()) {
+    try {
+      const parsed = JSON.parse(rawData);
+      if (isPlainObject(parsed)) {
+        return {
+          ...parsed,
+          id: parsed.id || message.id,
+          time_created: parsed.time_created ?? message.time_created,
+          time_updated: parsed.time_updated ?? message.time_updated
+        };
+      }
+    } catch {
+    }
+  }
+  return message;
+}
 function normalizeOpenCodeMessageRole(message = {}) {
-  return message.role || message.info?.role || message.author?.role || message.type || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.role || payload.info?.role || payload.author?.role || payload.type || "";
 }
 function normalizeOpenCodeMessageAgent(message = {}) {
-  return message.agent || message.info?.agent || message.mode?.agent || message.author?.agent || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.agent || payload.info?.agent || payload.mode?.agent || payload.author?.agent || "";
 }
 function normalizeOpenCodeMessageMode(message = {}) {
-  return message.mode || message.info?.mode || message.metadata?.mode || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.mode || payload.info?.mode || payload.metadata?.mode || "";
 }
 function normalizeOpenCodeMessageId(message = {}) {
-  return message.id || message.messageID || message.messageId || message.info?.id || message.data?.id || null;
+  const payload = openCodeMessagePayload(message);
+  return payload.id || payload.messageID || payload.messageId || payload.info?.id || payload.data?.id || message.id || null;
+}
+function openCodeMessageTimestampMs(message = {}, key = "updated") {
+  const payload = openCodeMessagePayload(message);
+  const time = payload.time || payload.info?.time || {};
+  const value = key === "completed" ? payload.time_completed ?? payload.timeCompleted ?? time.completed : key === "created" ? payload.time_created ?? payload.timeCreated ?? time.created : payload.time_updated ?? payload.timeUpdated ?? time.updated ?? payload.time_created ?? payload.timeCreated ?? time.created;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function isOpenCodeAssistantMessageRunning(message = {}) {
+  if (normalizeLooseToken(normalizeOpenCodeMessageRole(message)) !== "assistant") return false;
+  const started = openCodeMessageTimestampMs(message, "created") > 0;
+  if (!started) return false;
+  return openCodeMessageTimestampMs(message, "completed") === 0;
+}
+async function inspectOpenCodeSessionActivity(client, { sessionId, directory, limit = 10 } = {}) {
+  const messages = await readOpenCodeSessionMessages(client, { sessionId, directory, limit });
+  if (!messages) return { ok: false, reason: "message_inspection_unavailable", sessionId, directory };
+  const enriched = messages.map((message, index) => ({
+    message,
+    index,
+    sortTime: openCodeMessageTimestampMs(message, "updated") || index,
+    createdAt: openCodeMessageTimestampMs(message, "created"),
+    completedAt: openCodeMessageTimestampMs(message, "completed")
+  })).sort((a, b) => a.sortTime - b.sortTime || a.index - b.index);
+  const assistantMessages = enriched.filter((entry) => normalizeLooseToken(normalizeOpenCodeMessageRole(entry.message)) === "assistant");
+  const latestAssistant = assistantMessages.at(-1) || null;
+  const latest = enriched.at(-1) || null;
+  const running = latestAssistant ? isOpenCodeAssistantMessageRunning(latestAssistant.message) : false;
+  return {
+    ok: true,
+    sessionId,
+    directory,
+    count: messages.length,
+    running,
+    latestMessageId: latest ? normalizeOpenCodeMessageId(latest.message) : null,
+    latestAssistantMessageId: latestAssistant ? normalizeOpenCodeMessageId(latestAssistant.message) : null,
+    latestAssistantCreatedAt: latestAssistant?.createdAt || 0,
+    latestAssistantCompletedAt: latestAssistant?.completedAt || 0
+  };
 }
 function summarizeOpenCodeMessages(messages = [], { snippetLength = 160, maxMessages = 50 } = {}) {
   const list = Array.isArray(messages) ? messages.slice(0, maxMessages) : [];
@@ -10929,8 +11008,9 @@ async function probeOpenCodeSessionControl(client, { directory, agent, omitAgent
   };
 }
 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 : [];
+  const payload = openCodeMessagePayload(message);
+  const parts = [payload?.text, payload?.content, payload?.message, payload?.body?.text, payload?.data?.text];
+  const partList = Array.isArray(payload?.parts) ? payload.parts : Array.isArray(payload?.body?.parts) ? payload.body.parts : [];
   for (const part of partList) parts.push(part?.text, part?.content);
   return parts.filter((value) => typeof value === "string").join("\n");
 }
@@ -11094,7 +11174,7 @@ function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", w
 }
 function appendClickUpWebhookLocalLog(worktree, entry) {
   const logPath = clickUpWebhookLogPath(worktree);
-  fs5.mkdirSync(path5.dirname(logPath), { recursive: true });
+  fs5.mkdirSync(path6.dirname(logPath), { recursive: true });
   const safeEntry = { ...entry, at: entry.at || (/* @__PURE__ */ new Date()).toISOString() };
   fs5.appendFileSync(logPath, `${JSON.stringify(safeEntry)}
 `, "utf8");
@@ -11125,7 +11205,7 @@ function closeClickUpWebhookServer(server) {
   });
 }
 function managedClickUpWebhookKey({ worktree, state, config } = {}) {
-  return [path5.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
+  return [path6.resolve(worktree || process.cwd()), state?.webhookId || "", config?.webhook?.publicUrl || ""].join("|");
 }
 async function deleteClickUpWebhookBestEffort({ webhookId, clickupClient, worktree, reason = "cleanup" } = {}) {
   const id = String(webhookId || "").trim();
@@ -11148,6 +11228,7 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   entry.cleaning = true;
   const cleanup = (async () => {
     clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_started", reason, key: entry.key, webhookId: entry.state?.webhookId });
+    if (entry.assignmentWatchdog?.interval) clearInterval(entry.assignmentWatchdog.interval);
     const closeResult = await closeClickUpWebhookServer(entry.listener?.server);
     if (entry.listenerRegistry && entry.listener?.key) entry.listenerRegistry.delete(entry.listener.key);
     const preservedResult = { ok: true, skipped: true, reason: "remote_webhook_preserved" };
@@ -11161,10 +11242,10 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   if (result?.timeout) clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_timeout", reason, webhookId: entry.state?.webhookId });
   return result;
 }
-function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners } = {}) {
+function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners, assignmentWatchdog = null } = {}) {
   if (!isClickUpWebhookStateActive(state, config)) return null;
   const key = managedClickUpWebhookKey({ worktree, state, config });
-  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, assignmentWatchdog, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
   activeClickUpWebhookLifecycleRegistry.set(key, entry);
   installClickUpWebhookSignalHandlers();
   clickUpWebhookLifecycleLog(worktree, { type: "lifecycle_registered", key, webhookId: state.webhookId });
@@ -11229,8 +11310,8 @@ function writeClickUpWebhookAuditLog({ method, url, headers = {}, rawBody = "",
     let requestFile;
     if (level === "verbose") {
       const absoluteRequestFile = clickUpWebhookRequestFilePath(at, logDir);
-      fs5.mkdirSync(path5.dirname(absoluteRequestFile), { recursive: true });
-      requestFile = path5.relative(logDir, absoluteRequestFile).split(path5.sep).join("/");
+      fs5.mkdirSync(path6.dirname(absoluteRequestFile), { recursive: true });
+      requestFile = path6.relative(logDir, absoluteRequestFile).split(path6.sep).join("/");
       const parsedBody = payload || (() => {
         try {
           return JSON.parse(Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody || ""));
@@ -11454,19 +11535,54 @@ function scheduleClickUpStartupReconciliation({ config, state = {}, worktree = p
   timer?.unref?.();
   return { scheduled: true, delayMs: normalizedDelayMs, timer };
 }
-async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
+function scheduleClickUpAssignmentWatchdog({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, scheduler = setInterval, intervalMs = config?.opencode?.assignmentWatchdogIntervalMs ?? CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS, saveState = null, reconcile = reconcileClickUpStartup } = {}) {
+  const normalizedIntervalMs = normalizeNonNegativeInteger(intervalMs, CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS);
+  if (!normalizedIntervalMs) {
+    clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_disabled", webhookId: state?.webhookId || null });
+    return { scheduled: false, intervalMs: 0, reason: "disabled" };
+  }
+  let running = false;
+  const run = () => {
+    if (running) {
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_tick_skipped", reason: "previous_tick_running" });
+      return;
+    }
+    running = true;
+    const latestState = readClickUpWebhookState(worktree, config);
+    Promise.resolve().then(() => reconcile({
+      config,
+      state: latestState?.webhookId ? latestState : state,
+      worktree,
+      clickupClient,
+      openCodeClient,
+      saveState,
+      assignmentMode: "watchdog"
+    })).catch((error) => {
+      clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+    }).finally(() => {
+      running = false;
+    });
+  };
+  const interval = scheduler(run, normalizedIntervalMs);
+  interval?.unref?.();
+  clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_scheduled", intervalMs: normalizedIntervalMs, webhookId: state?.webhookId || null });
+  return { scheduled: true, intervalMs: normalizedIntervalMs, interval };
+}
+async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT, assignmentMode = "startup" } = {}) {
+  const watchdogMode = assignmentMode === "watchdog";
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_started" : "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
   if (!config || !clickupClient?.listAssignedTasks) {
     const skipped = { ok: true, skipped: true, reason: "clickup_task_listing_unavailable", assigned: 0, comments: 0 };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...skipped });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...skipped });
     return skipped;
   }
   const readiness = await waitForReadiness(openCodeClient, { worktree, now, opencodeBaseUrl: config.opencode?.baseUrl });
   appendClickUpWebhookLocalLog(worktree, { type: readiness.ok ? "startup_reconciliation_readiness_ready" : "startup_reconciliation_readiness_failed", ...readiness });
   if (!readiness.ok) {
     const failed = { ok: false, skipped: true, reason: "opencode_not_ready", readiness, assigned: 0, comments: 0, ignored: 0, errors: 1, undelivered: 1, tasks: [], validation: { undelivered: 1, emptyPromptSessions: [] } };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_failed", reason: failed.reason, readiness });
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...failed });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_failed" : "startup_reconciliation_failed", reason: failed.reason, readiness });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...failed });
     return failed;
   }
   let authorizedUserId = "";
@@ -11484,6 +11600,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     if (saveState) saveState(nextState);
   };
   const lastWebhookMs = clickUpTimestampMs(mutableState.lastWebhookAt);
+  const startupCommentStartMs = lastWebhookMs || Math.max(0, now().getTime() - CLICKUP_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS);
   const ignored = new Set((config.routing?.ignoredStatuses || CLICKUP_WEBHOOK_TERMINAL_STATUSES).map(normalizeClickUpStatus));
   const routed = { assigned: 0, comments: 0, ignored: 0, errors: 0, undelivered: 0, tasks: [] };
   const listed = await clickupClient.listAssignedTasks({ assigneeId: config.routing.productManagerAssigneeId, limit });
@@ -11502,9 +11619,29 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       routed.ignored += 1;
       continue;
     }
+    if (watchdogMode) {
+      const existingMetadata = clickUpTaskAgentMetadata(task, config.routing.metadataFieldId);
+      const metadata = normalizeAgentMetadataJson(existingMetadata);
+      const rawSessionId = getNestedMetadataValue(metadata, config.routing.metadataKey);
+      const sessionId = typeof rawSessionId === "string" && rawSessionId.startsWith("ses_") ? rawSessionId : "";
+      const directory = String(getNestedMetadataValue(metadata, "task.worktree") || "").trim();
+      if (sessionId) {
+        try {
+          const activity = await inspectOpenCodeSessionActivity(openCodeClient, { sessionId, directory });
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity", taskId, sessionId, directory: directory || null, ...activity });
+          if (activity.running) {
+            routed.ignored += 1;
+            routed.tasks.push({ taskId, action: "ignored", ok: true, sessionId, branch: getNestedMetadataValue(metadata, "task.branch") || null, worktree: directory || null, verification: "session_running", delivered: false });
+            continue;
+          }
+        } catch (error) {
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity_failed", taskId, sessionId, directory: directory || null, message: error.message });
+        }
+      }
+    }
     try {
       const result = await routeClickUpWebhookEvent({
-        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true },
+        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true, assignment_watchdog: watchdogMode },
         config,
         state: mutableState,
         worktree,
@@ -11554,12 +11691,12 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: "error", sessionId: null, reason: "startup_reconciliation_task_failed" });
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_task_failed", source: "startup_reconciliation_task" });
     }
-    if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
+    if (!startupCommentStartMs || !clickupClient?.getTaskComments) continue;
     try {
-      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: lastWebhookMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
+      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: startupCommentStartMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
       for (const comment of clickUpCommentListItems(commentsResponse).slice(0, CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT)) {
         const commentMs = clickUpCommentUpdatedMs(comment);
-        if (!commentMs || commentMs <= lastWebhookMs) continue;
+        if (!commentMs || commentMs <= startupCommentStartMs) continue;
         const authorId = clickUpCommentAuthorId(comment);
         if (authorId && (authorId === config.routing.ignoredCommentAuthorId || authorId === authorizedUserId)) continue;
         if (!clickUpCommentMentionsProductManager(comment, config.routing)) continue;
@@ -11586,11 +11723,11 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_comments_failed", source: "startup_reconciliation_comments" });
     }
   }
-  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId);
+  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId && task.verification !== "session_running");
   if (emptyPromptSessions.length > 0) {
     appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_validation_failed", tasks: emptyPromptSessions });
   }
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...routed });
   return { ok: routed.errors === 0 && routed.undelivered === 0, ...routed, validation: { undelivered: routed.undelivered, emptyPromptSessions } };
 }
 function clickUpWebhookExpectedPath(config) {
@@ -11785,17 +11922,17 @@ function startClickUpWebhookListener({ config, state, worktree, clickupClient, o
   return result;
 }
 function legacyVariantPath(destinationPath) {
-  const parsed = path5.parse(destinationPath);
+  const parsed = path6.parse(destinationPath);
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-  if (parsed.ext) return path5.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
-  return path5.join(parsed.dir, `${parsed.base}.legacy-${stamp}`);
+  if (parsed.ext) return path6.join(parsed.dir, `${parsed.name}.legacy-${stamp}${parsed.ext}`);
+  return path6.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 (path5.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
+  if (path6.isAbsolute(trimmed)) return { ok: true, taskPath: trimmed };
   if (normalized === "tasks" || normalized.startsWith("tasks/")) {
     return {
       ok: false,
@@ -11814,12 +11951,12 @@ function mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, g
   const sourceWasTracked = isGitTracked(gitState, sourcePath);
   if (gitAwareMoveIfTracked(sourcePath, destinationPath, gitState)) return;
   if (!fs5.existsSync(destinationPath)) {
-    fs5.mkdirSync(path5.dirname(destinationPath), { recursive: true });
+    fs5.mkdirSync(path6.dirname(destinationPath), { recursive: true });
     fs5.renameSync(sourcePath, destinationPath);
     if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
     return;
   }
-  const ext = path5.extname(destinationPath).toLowerCase();
+  const ext = path6.extname(destinationPath).toLowerCase();
   if ([".yaml", ".yml", ".json"].includes(ext)) {
     const sourceRaw = fs5.readFileSync(sourcePath, "utf8");
     const destRaw = fs5.readFileSync(destinationPath, "utf8");
@@ -11854,14 +11991,14 @@ ${sourceRaw}
   fs5.renameSync(sourcePath, preservedPath);
   stageGitAwareMerge(sourcePath, preservedPath, gitState);
 }
-function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path5.basename(sourcePath), gitState = null) {
+function mergePathIntoDestination(sourcePath, destinationPath, relativeSource = path6.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 (!fs5.existsSync(destinationPath)) {
-      fs5.mkdirSync(path5.dirname(destinationPath), { recursive: true });
+      fs5.mkdirSync(path6.dirname(destinationPath), { recursive: true });
       fs5.renameSync(sourcePath, destinationPath);
       if (sourceWasTracked) stageGitAwareMerge(sourcePath, destinationPath, gitState);
       return;
@@ -11869,9 +12006,9 @@ function mergePathIntoDestination(sourcePath, destinationPath, relativeSource =
     fs5.mkdirSync(destinationPath, { recursive: true });
     for (const entry of fs5.readdirSync(sourcePath)) {
       mergePathIntoDestination(
-        path5.join(sourcePath, entry),
-        path5.join(destinationPath, entry),
-        path5.join(relativeSource, entry),
+        path6.join(sourcePath, entry),
+        path6.join(destinationPath, entry),
+        path6.join(relativeSource, entry),
         gitState
       );
     }
@@ -11881,7 +12018,7 @@ function mergePathIntoDestination(sourcePath, destinationPath, relativeSource =
   mergeFileIntoDestination(sourcePath, destinationPath, relativeSource, gitState);
 }
 function isOptimaPluginPackageWorktree(worktree) {
-  const packageJsonPath = path5.join(worktree, "package.json");
+  const packageJsonPath = path6.join(worktree, "package.json");
   if (!fs5.existsSync(packageJsonPath)) return false;
   try {
     const pkg = JSON.parse(fs5.readFileSync(packageJsonPath, "utf8"));
@@ -11893,51 +12030,51 @@ function isOptimaPluginPackageWorktree(worktree) {
 function migrateLegacyOptimaLayout(worktree) {
   const gitState = gitMigrationState(worktree);
   const migrations = [
-    [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")],
+    [path6.join(legacyOrbitaDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".orbita", "orbita.yaml")],
+    [path6.join(legacyOrbitaDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".orbita", "staticeng.yaml")],
+    [path6.join(legacyOrbitaDir(worktree), ".config"), optimaLocalConfigDir(worktree), path6.join(".orbita", ".config")],
+    [path6.join(legacyOrbitaDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".orbita", "config")],
+    [path6.join(legacyOrbitaDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".orbita", "runtime")],
+    [path6.join(legacyOrbitaDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".orbita", "generated")],
     [legacyOrbitaDir(worktree), optimaDir(worktree), ".orbita"],
-    [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")],
+    [path6.join(legacyStaticEngDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".staticeng", "staticeng.yaml")],
+    [path6.join(legacyStaticEngDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".staticeng", "orbita.yaml")],
+    [path6.join(legacyStaticEngDir(worktree), ".config"), optimaLocalConfigDir(worktree), path6.join(".staticeng", ".config")],
+    [path6.join(legacyStaticEngDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".staticeng", "config")],
+    [path6.join(legacyStaticEngDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".staticeng", "runtime")],
+    [path6.join(legacyStaticEngDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".staticeng", "generated")],
     [legacyStaticEngDir(worktree), optimaDir(worktree), ".staticeng"],
-    [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")],
+    [path6.join(legacyNomadworkDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "nomadworks.yaml")],
+    [path6.join(legacyNomadworksDir(worktree), "nomadworks.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "nomadworks.yaml")],
+    [path6.join(legacyNomadworkDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "staticeng.yaml")],
+    [path6.join(legacyNomadworksDir(worktree), "staticeng.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "staticeng.yaml")],
+    [path6.join(legacyNomadworkDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".nomadwork", "orbita.yaml")],
+    [path6.join(legacyNomadworksDir(worktree), "orbita.yaml"), repoConfigPath(worktree), path6.join(".nomadworks", "orbita.yaml")],
+    [path6.join(legacyNomadworkDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".nomadwork", "runtime")],
+    [path6.join(legacyNomadworksDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".nomadworks", "runtime")],
+    [path6.join(legacyNomadworkDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".nomadwork", "generated")],
+    [path6.join(legacyNomadworksDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".nomadworks", "generated")],
+    [path6.join(legacyNomadworkDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".nomadwork", "config")],
+    [path6.join(legacyNomadworksDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".nomadworks", "config")],
     [legacyNomadworkDir(worktree), optimaDir(worktree), ".nomadwork"],
     [legacyNomadworksDir(worktree), optimaDir(worktree), ".nomadworks"],
-    [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"]
+    [path6.join(worktree, "tasks"), optimaTasksDir(worktree), "tasks"],
+    [path6.join(worktree, "evidences"), optimaEvidencesDir(worktree), "evidences"],
+    [path6.join(worktree, "docs", "scrs"), optimaScrsDir(worktree), path6.join("docs", "scrs")],
+    [path6.join(worktree, "codemap.yml"), optimaCodemapPath(worktree), "codemap.yml"],
+    [path6.join(worktree, "codemap.yaml"), optimaCodemapPath(worktree), "codemap.yaml"]
   ];
   if (!isOptimaPluginPackageWorktree(worktree)) {
-    migrations.push([path5.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
+    migrations.push([path6.join(worktree, "policies"), repoPoliciesDir(worktree), "policies"]);
   }
   for (const [source, destination, relativeSource] of migrations) {
     if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
   for (const [source, destination, relativeSource] of [
-    [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")]
+    [path6.join(optimaDir(worktree), "optima.yaml"), repoConfigPath(worktree), path6.join(".optima", "optima.yaml")],
+    [path6.join(optimaDir(worktree), "config"), optimaLocalConfigDir(worktree), path6.join(".optima", "config")],
+    [path6.join(optimaDir(worktree), "runtime"), path6.join(optimaLocalConfigDir(worktree), "runtime"), path6.join(".optima", "runtime")],
+    [path6.join(optimaDir(worktree), "generated"), path6.join(optimaLocalConfigDir(worktree), "generated"), path6.join(".optima", "generated")]
   ]) {
     if (fs5.existsSync(source)) mergePathIntoDestination(source, destination, relativeSource, gitState);
   }
@@ -11986,7 +12123,7 @@ function toModelString(provider, model) {
 }
 function readTaskMetadata(taskPath, worktree) {
   if (!taskPath) return {};
-  const absoluteTaskPath = path5.isAbsolute(taskPath) ? taskPath : path5.join(worktree, taskPath);
+  const absoluteTaskPath = path6.isAbsolute(taskPath) ? taskPath : path6.join(worktree, taskPath);
   if (!fs5.existsSync(absoluteTaskPath)) return {};
   try {
     const raw = fs5.readFileSync(absoluteTaskPath, "utf8");
@@ -12031,18 +12168,18 @@ function loadDiscussionRegistry(worktree) {
 }
 function saveDiscussionRegistry(worktree, registry) {
   const registryPath = runtimeDiscussionRegistryPath(worktree);
-  const runtimeDir = path5.dirname(registryPath);
+  const runtimeDir = path6.dirname(registryPath);
   if (!fs5.existsSync(runtimeDir)) fs5.mkdirSync(runtimeDir, { recursive: true });
   fs5.writeFileSync(registryPath, JSON.stringify(registry, null, 2), "utf8");
 }
 function runtimeDiscussionsDir(worktree) {
-  return path5.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
+  return path6.join(optimaLocalConfigDir(worktree), "runtime", "discussions");
 }
 function archivedRuntimeDiscussionsDir(worktree) {
-  return path5.join(runtimeDiscussionsDir(worktree), "archive");
+  return path6.join(runtimeDiscussionsDir(worktree), "archive");
 }
 function finalDiscussionsDir(worktree) {
-  return path5.join(optimaTasksDir(worktree), "discussions");
+  return path6.join(optimaTasksDir(worktree), "discussions");
 }
 function nextDiscussionIdentity(worktree, title) {
   const discussionsDir = finalDiscussionsDir(worktree);
@@ -12053,11 +12190,11 @@ function nextDiscussionIdentity(worktree, title) {
   while (true) {
     const id = `DISCUSSION-${String(sequence).padStart(3, "0")}`;
     const filename = `${id}-${slugifyTitle(title)}.md`;
-    const summaryRelativePath = path5.join(".optima", "tasks", "discussions", filename);
-    const summaryAbsolutePath = path5.join(worktree, summaryRelativePath);
+    const summaryRelativePath = path6.join(".optima", "tasks", "discussions", filename);
+    const summaryAbsolutePath = path6.join(worktree, summaryRelativePath);
     const transcriptFilename = `${id}-transcript.md`;
-    const transcriptRelativePath = path5.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
-    const transcriptAbsolutePath = path5.join(worktree, transcriptRelativePath);
+    const transcriptRelativePath = path6.join(".optima", ".config", "runtime", "discussions", transcriptFilename);
+    const transcriptAbsolutePath = path6.join(worktree, transcriptRelativePath);
     if (!fs5.existsSync(summaryAbsolutePath) && !fs5.existsSync(transcriptAbsolutePath)) {
       return {
         id,
@@ -12082,11 +12219,11 @@ function findDiscussionById(worktree, discussionID) {
   return {
     id: discussionID,
     filename,
-    summaryRelativePath: path5.join(".optima", "tasks", "discussions", filename),
-    summaryAbsolutePath: path5.join(discussionsDir, filename),
+    summaryRelativePath: path6.join(".optima", "tasks", "discussions", filename),
+    summaryAbsolutePath: path6.join(discussionsDir, filename),
     transcriptFilename,
-    transcriptRelativePath: path5.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
-    transcriptAbsolutePath: path5.join(runtimeDiscussionsDir(worktree), transcriptFilename)
+    transcriptRelativePath: path6.join(".optima", ".config", "runtime", "discussions", transcriptFilename),
+    transcriptAbsolutePath: path6.join(runtimeDiscussionsDir(worktree), transcriptFilename)
   };
 }
 function parseDiscussionFile(filePath) {
@@ -12169,15 +12306,15 @@ async function appendMessageIfNeeded(client, worktree, registry, sessionID, mess
   });
   const text = extractTextParts(response.data.parts || []);
   if (!text) return;
-  appendDiscussionMessage(path5.join(worktree, discussion.transcriptPath), speaker, text, messageID);
+  appendDiscussionMessage(path6.join(worktree, discussion.transcriptPath), speaker, text, messageID);
   discussion.appendedMessageIDs ??= [];
   discussion.appendedMessageIDs.push(messageID);
   saveDiscussionRegistry(worktree, registry);
 }
 async function summarizeDiscussionWithBA(client, worktree, discussion) {
-  const transcriptPath = path5.join(worktree, discussion.transcriptPath);
-  const summaryPath = path5.join(worktree, discussion.summaryPath);
-  const summaryDir = path5.dirname(summaryPath);
+  const transcriptPath = path6.join(worktree, discussion.transcriptPath);
+  const summaryPath = path6.join(worktree, discussion.summaryPath);
+  const summaryDir = path6.dirname(summaryPath);
   if (!fs5.existsSync(summaryDir)) fs5.mkdirSync(summaryDir, { recursive: true });
   const hasExistingSummary = fs5.existsSync(summaryPath);
   const priorMtimeMs = hasExistingSummary ? fs5.statSync(summaryPath).mtimeMs : null;
@@ -12280,11 +12417,11 @@ async function summarizeDiscussionWithBA(client, worktree, discussion) {
   return { confirmation, summaryPath, transcriptPath, hasExistingSummary, priorMtimeMs };
 }
 function archiveDiscussionTranscript(worktree, transcriptRelativePath) {
-  const sourcePath = path5.join(worktree, transcriptRelativePath);
+  const sourcePath = path6.join(worktree, transcriptRelativePath);
   if (!fs5.existsSync(sourcePath)) return null;
   const archiveDir = archivedRuntimeDiscussionsDir(worktree);
   if (!fs5.existsSync(archiveDir)) fs5.mkdirSync(archiveDir, { recursive: true });
-  const targetPath = path5.join(archiveDir, path5.basename(sourcePath));
+  const targetPath = path6.join(archiveDir, path6.basename(sourcePath));
   fs5.renameSync(sourcePath, targetPath);
   return targetPath;
 }
@@ -12303,7 +12440,7 @@ async function finalizeClosingDiscussion(client, worktree, registry, sessionID,
   if (!summaryContent) {
     throw new Error(`Discussion summary file is empty at ${discussion.summaryPath}`);
   }
-  const transcriptPath = path5.join(worktree, discussion.transcriptPath);
+  const transcriptPath = path6.join(worktree, discussion.transcriptPath);
   setDiscussionStatus(transcriptPath, "closed");
   const archivedTranscriptPath = archiveDiscussionTranscript(worktree, discussion.transcriptPath);
   delete registry.active[sessionID];
@@ -12311,7 +12448,7 @@ async function finalizeClosingDiscussion(client, worktree, registry, sessionID,
   return {
     confirmation,
     summaryPath: discussion.summaryPath,
-    archivedTranscriptPath: archivedTranscriptPath ? path5.relative(worktree, archivedTranscriptPath) : path5.join(".optima", ".config", "runtime", "discussions", "archive", path5.basename(discussion.transcriptPath))
+    archivedTranscriptPath: archivedTranscriptPath ? path6.relative(worktree, archivedTranscriptPath) : path6.join(".optima", ".config", "runtime", "discussions", "archive", path6.basename(discussion.transcriptPath))
   };
 }
 function normalizeTeamMode(value) {
@@ -12383,7 +12520,7 @@ function syncGeneratedPolicies(worktree, repoCfg) {
   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 = path5.join(BUNDLE_POLICIES_DIR, file);
+    const sourcePath = path6.join(BUNDLE_POLICIES_DIR, file);
     const source = fs5.readFileSync(sourcePath, "utf8").trimEnd();
     const generated = [
       "<!--",
@@ -12395,18 +12532,18 @@ function syncGeneratedPolicies(worktree, repoCfg) {
       source,
       ""
     ].join("\n");
-    fs5.writeFileSync(path5.join(generatedDir, file), generated, "utf8");
+    fs5.writeFileSync(path6.join(generatedDir, file), generated, "utf8");
   }
 }
 function ensureReadmeFile(dirPath, content) {
   if (!fs5.existsSync(dirPath)) fs5.mkdirSync(dirPath, { recursive: true });
-  const readmePath = path5.join(dirPath, "README.md");
+  const readmePath = path6.join(dirPath, "README.md");
   if (!fs5.existsSync(readmePath)) {
     fs5.writeFileSync(readmePath, content, "utf8");
   }
 }
 function ensureFileIfMissing(filePath, content) {
-  if (!fs5.existsSync(path5.dirname(filePath))) fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
+  if (!fs5.existsSync(path6.dirname(filePath))) fs5.mkdirSync(path6.dirname(filePath), { recursive: true });
   if (!fs5.existsSync(filePath)) fs5.writeFileSync(filePath, content, "utf8");
 }
 function currentTasksRegistryContent() {
@@ -12493,13 +12630,13 @@ Never place implementation evidence under root \`evidences/\`.
 }
 function ensureOptimaTaskTemplates(worktree) {
   const tasksDir = optimaTasksDir(worktree);
-  ensureFileIfMissing(path5.join(tasksDir, "task-template.md"), taskTemplateContent());
-  ensureFileIfMissing(path5.join(tasksDir, "subtask-template.md"), subtaskTemplateContent());
+  ensureFileIfMissing(path6.join(tasksDir, "task-template.md"), taskTemplateContent());
+  ensureFileIfMissing(path6.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");
+  const templatePath = path6.join(TEMPLATES_DIR, "optima.yaml.template");
   if (!fs5.existsSync(templatePath)) return false;
   const agentIds = fs5.existsSync(BUNDLE_AGENTS_DIR) ? fs5.readdirSync(BUNDLE_AGENTS_DIR).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", "")) : [];
   let optimaConfig = fs5.readFileSync(templatePath, "utf8");
@@ -12518,9 +12655,9 @@ function scaffoldOptimaConfig(worktree, teamMode = "full") {
 function scaffoldOptimaRootCodemap(worktree) {
   const rootCodemapPath = optimaCodemapPath(worktree);
   if (fs5.existsSync(rootCodemapPath)) return false;
-  const templatePath = path5.join(TEMPLATES_DIR, "codemap.yml.template");
+  const templatePath = path6.join(TEMPLATES_DIR, "codemap.yml.template");
   if (!fs5.existsSync(templatePath)) return false;
-  const codemapConfig = fs5.readFileSync(templatePath, "utf8").replace("{{projectName}}", path5.basename(worktree));
+  const codemapConfig = fs5.readFileSync(templatePath, "utf8").replace("{{projectName}}", path6.basename(worktree));
   ensureFileIfMissing(rootCodemapPath, codemapConfig);
   return fs5.existsSync(rootCodemapPath);
 }
@@ -12529,10 +12666,10 @@ function ensureOptimaRegistries(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());
+  ensureFileIfMissing(path6.join(tasksDir, "current.md"), currentTasksRegistryContent());
+  ensureFileIfMissing(path6.join(tasksDir, "done.md"), doneTasksRegistryContent());
+  ensureFileIfMissing(path6.join(scrsDir, "current.md"), currentScrRegistryContent());
+  ensureFileIfMissing(path6.join(scrsDir, "done.md"), doneScrRegistryContent());
 }
 function scaffoldOptimaReadmes(worktree) {
   ensureReadmeFile(repoPoliciesDir(worktree), REPO_LOCAL_POLICIES_README);
@@ -12694,12 +12831,12 @@ function shouldRegisterWorkflowProductManager(options = {}, worktree = process.c
 }
 function isClickUpDerivedWorktreeSibling(candidate, basePath) {
   if (typeof candidate !== "string" || typeof basePath !== "string" || !candidate.trim() || !basePath.trim()) return false;
-  const resolvedCandidate = path5.resolve(candidate);
-  const resolvedBase = path5.resolve(basePath);
-  const baseParent = path5.dirname(resolvedBase);
-  if (path5.dirname(resolvedCandidate) !== baseParent) return false;
-  const baseName = path5.basename(resolvedBase);
-  const candidateName = path5.basename(resolvedCandidate);
+  const resolvedCandidate = path6.resolve(candidate);
+  const resolvedBase = path6.resolve(basePath);
+  const baseParent = path6.dirname(resolvedBase);
+  if (path6.dirname(resolvedCandidate) !== baseParent) return false;
+  const baseName = path6.basename(resolvedBase);
+  const candidateName = path6.basename(resolvedCandidate);
   if (!candidateName.startsWith(`${baseName}-`)) return false;
   const branchSlug = candidateName.slice(baseName.length + 1);
   const parts = branchSlug.split("-").filter(Boolean);
@@ -12711,7 +12848,7 @@ function isClickUpDerivedWorktreeSibling(candidate, basePath) {
     if (!candidateStat.isDirectory() || candidateStat.isSymbolicLink()) return false;
     const realCandidate = fs5.realpathSync.native(resolvedCandidate);
     const realBaseParent = fs5.realpathSync.native(baseParent);
-    return path5.dirname(realCandidate) === realBaseParent && path5.basename(realCandidate) === candidateName;
+    return path6.dirname(realCandidate) === realBaseParent && path6.basename(realCandidate) === candidateName;
   } catch {
     return false;
   }
@@ -12719,15 +12856,15 @@ function isClickUpDerivedWorktreeSibling(candidate, basePath) {
 function resolveSessionToolDirectory({ requestedDirectory, context, pluginWorktree, clickUpWebhookValidation } = {}) {
   const safe = safeWorktreeOrFailure(context, pluginWorktree);
   if (!safe.ok) return { ok: false, error: safe.message };
-  const requested = String(requestedDirectory || "").trim() ? path5.resolve(safe.worktree, String(requestedDirectory).trim()) : safe.worktree;
+  const requested = String(requestedDirectory || "").trim() ? path6.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: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path6.resolve(clickUpBasePath) };
   }
   if (clickUpBasePath && isClickUpDerivedWorktreeSibling(requested, clickUpBasePath)) {
-    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path5.resolve(clickUpBasePath) };
+    return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_derived_worktree", clickupBasePath: path6.resolve(clickUpBasePath) };
   }
   return {
     ok: false,
@@ -12761,8 +12898,8 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
       if (!enabled) continue;
     }
     const promptOptions = { preferCompactPromptDocs: repoCfg.features?.compact_prompt_docs !== false };
-    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 bundledDefinition = loadAgentDefinition(path6.join(BUNDLE_AGENTS_DIR, file), worktree, promptOptions);
+    const repoDefinition = loadAgentDefinition(path6.join(repoAgentDefinitions, file), worktree, promptOptions) || loadAgentDefinition(path6.join(legacyAgentsDir, file), worktree, promptOptions);
     const activeDefinition = repoDefinition || bundledDefinition;
     if (!activeDefinition) continue;
     const { data } = activeDefinition;
@@ -12771,7 +12908,7 @@ function buildOptimaAgents(repoCfg, operatingTeamMode, worktree, debugDir, optio
     if (modePromptFragment) finalPrompt = `${finalPrompt}
 
 ${modePromptFragment}`;
-    const additionFragment = loadMarkdownFragment(path5.join(repoAgentAdditions, file), worktree);
+    const additionFragment = loadMarkdownFragment(path6.join(repoAgentAdditions, file), worktree);
     if (additionFragment) {
       finalPrompt = `${finalPrompt}
 
@@ -12824,7 +12961,7 @@ Use this Optima-provided fallback when the current task worktree lacks docs/core
     }
     ourAgents[id] = agentConfig;
     if (repoCfg.features?.debug_dumps !== false) {
-      const debugPath = path5.join(debugDir, `${id}.md`);
+      const debugPath = path6.join(debugDir, `${id}.md`);
       const { prompt, ...dumpConfig } = agentConfig;
       const debugHeader = `---
 ${import_yaml3.default.stringify(dumpConfig).trim()}
@@ -12904,7 +13041,17 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
           ...listenerState,
           listener: { bindHost: clickUpWebhookValidation.config.webhook.bindHost, bindPort: clickUpWebhookValidation.config.webhook.bindPort, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
         }, clickUpWebhookValidation.config);
-        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry });
+        const assignmentWatchdog = scheduleClickUpAssignmentWatchdog({
+          config: clickUpWebhookValidation.config,
+          state: activeState,
+          worktree,
+          clickupClient: lifecycleClickUpClient,
+          openCodeClient: input.client,
+          scheduler: input.assignmentWatchdogScheduler,
+          intervalMs: input.assignmentWatchdogIntervalMs,
+          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, clickUpWebhookValidation.config)
+        });
+        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry, assignmentWatchdog });
         scheduleClickUpStartupReconciliation({
           config: clickUpWebhookValidation.config,
           state: activeState,
@@ -12966,8 +13113,8 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
         migrateLegacyOptimaLayout(toolWorktree);
         const cfgDir = optimaConfigDir(toolWorktree);
         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");
+        const optimaTmplPath = path6.join(TEMPLATES_DIR, "optima.yaml.template");
+        const codemapTmplPath = path6.join(TEMPLATES_DIR, "codemap.yml.template");
         if (!fs5.existsSync(optimaTmplPath) || !fs5.existsSync(codemapTmplPath)) {
           return "Error: Initialization templates not found in plugin.";
         }
@@ -13089,14 +13236,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 = path5.resolve(safe.worktree, args.summary_path || "");
+        const summaryPath = path6.resolve(safe.worktree, args.summary_path || "");
         if (!fs5.existsSync(summaryPath)) return `FAIL: summary_path not found: ${summaryPath}`;
-        const taskPath = args.task_path ? path5.resolve(safe.worktree, args.task_path) : "";
+        const taskPath = args.task_path ? path6.resolve(safe.worktree, args.task_path) : "";
         const payload = buildClickUpSummaryPayload({
           summaryMarkdown: fs5.readFileSync(summaryPath, "utf8"),
-          summaryPath: path5.relative(safe.worktree, summaryPath),
+          summaryPath: path6.relative(safe.worktree, summaryPath),
           taskMarkdown: taskPath && fs5.existsSync(taskPath) ? fs5.readFileSync(taskPath, "utf8") : "",
-          taskPath: taskPath ? path5.relative(safe.worktree, taskPath) : "",
+          taskPath: taskPath ? path6.relative(safe.worktree, taskPath) : "",
           branch: args.branch,
           worktree: args.worktree,
           pr: args.pr
@@ -13175,12 +13322,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 = path5.resolve(safe.worktree, args.markdown_path || "");
+        const markdownPath = path6.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: fs5.readFileSync(markdownPath, "utf8"),
-          sourcePath: path5.relative(safe.worktree, markdownPath),
+          sourcePath: path6.relative(safe.worktree, markdownPath),
           parentBranch: args.parent_branch,
           parentTaskType: args.parent_task_type || "Tarea",
           apply: String(args.apply || "").toLowerCase() === "true"
@@ -13379,7 +13526,7 @@ Backfilled messages: ${backfilled}`;
         if (!existing) {
           return "FAIL: No active discussion exists for this session.";
         }
-        const discussionPath = path5.join(toolWorktree, existing.transcriptPath);
+        const discussionPath = path6.join(toolWorktree, existing.transcriptPath);
         setDiscussionStatus(discussionPath, "summarizing");
         existing.status = "summarizing";
         saveDiscussionRegistry(toolWorktree, toolRegistry);
@@ -13431,7 +13578,7 @@ Reason: ${err.message}`;
         try {
           const sessionResult = await client.session.create({
             query: { directory: workflowDirectory },
-            body: { title: `Workflow Run: ${path5.basename(workflowTaskPath)}` }
+            body: { title: `Workflow Run: ${path6.basename(workflowTaskPath)}` }
           });
           const sessionId = sessionResult.data.id;
           activeWorkflows.set(sessionId, { pmaSessionId, taskPath: workflowTaskPath, track: workflowTrack, directory: workflowDirectory });
@@ -13560,7 +13707,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, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, 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 };
+OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, inspectOpenCodeSessionActivity, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpAssignmentWatchdog, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, 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 };
 
 // src/sanitize_cli.js
 var { migrateLegacyOptimaLayout: migrateLegacyOptimaLayout2 } = OptimaPlugin.__internals;
@@ -13616,13 +13763,13 @@ function usage() {
 }
 function expandHome(inputPath) {
   if (!inputPath || inputPath === "~") return os2.homedir();
-  if (inputPath.startsWith("~/")) return path6.join(os2.homedir(), inputPath.slice(2));
+  if (inputPath.startsWith("~/")) return path7.join(os2.homedir(), inputPath.slice(2));
   return inputPath;
 }
 function resolveOpenCodeDbPath(inputPath = null) {
   const expanded = expandHome(inputPath || process.env.OPTIMA_OPENCODE_DB_PATH || DEFAULT_DB_PATH);
   try {
-    if (fs6.existsSync(expanded) && fs6.statSync(expanded).isDirectory()) return path6.join(expanded, "opencode.db");
+    if (fs6.existsSync(expanded) && fs6.statSync(expanded).isDirectory()) return path7.join(expanded, "opencode.db");
   } catch {
     return expanded;
   }
@@ -13686,8 +13833,8 @@ function extractOpenedPathValue(value) {
 }
 function normalizePathCandidate(candidate) {
   const expanded = expandHome(candidate);
-  if (!path6.isAbsolute(expanded)) return null;
-  return path6.resolve(expanded);
+  if (!path7.isAbsolute(expanded)) return null;
+  return path7.resolve(expanded);
 }
 function discoverOpenCodePaths(dbPath) {
   const resolvedDb = resolveOpenCodeDbPath(dbPath);
@@ -13716,27 +13863,27 @@ function discoverOpenCodePaths(dbPath) {
 function collectMarkdownOverridesFrom(baseDir) {
   const files = [];
   for (const dirName of OVERRIDE_DIRS) {
-    const dirPath = path6.join(baseDir, dirName);
+    const dirPath = path7.join(baseDir, dirName);
     if (!fs6.existsSync(dirPath)) continue;
     for (const entry of fs6.readdirSync(dirPath, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".md")) continue;
       if (entry.name.toLowerCase() === "readme.md") continue;
-      files.push(path6.join(dirPath, entry.name));
+      files.push(path7.join(dirPath, entry.name));
     }
   }
   return files;
 }
 function collectOverrideFiles(worktree) {
-  return collectMarkdownOverridesFrom(path6.join(worktree, ".optima")).sort();
+  return collectMarkdownOverridesFrom(path7.join(worktree, ".optima")).sort();
 }
 function collectPlannedOverrideFiles(worktree) {
   return [
     ...collectOverrideFiles(worktree),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".staticeng")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".orbita")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".nomadwork")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".nomadworks"))
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".staticeng")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".orbita")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadwork")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadworks"))
   ].sort();
 }
 var CRC_TABLE = (() => {
@@ -13769,14 +13916,14 @@ function writeUInt16LE(value) {
   return buffer;
 }
 function createZipBackup(files, backupPath) {
-  fs6.mkdirSync(path6.dirname(backupPath), { recursive: true });
+  fs6.mkdirSync(path7.dirname(backupPath), { recursive: true });
   const localParts = [];
   const centralParts = [];
   let offset = 0;
   const now = dosTimeDate();
   for (const filePath of files) {
     const data = fs6.readFileSync(filePath);
-    const name = path6.resolve(filePath).replace(/^\//, "").split(path6.sep).join("/");
+    const name = path7.resolve(filePath).replace(/^\//, "").split(path7.sep).join("/");
     const nameBuffer = Buffer.from(name, "utf8");
     const crc = crc32(data);
     const local = Buffer.concat([
@@ -13838,15 +13985,15 @@ function validationStatus(result) {
   return result.ok ? "passed" : "failed";
 }
 function hasLegacyMarker(worktree) {
-  return fs6.existsSync(path6.join(worktree, ".staticeng")) || fs6.existsSync(path6.join(worktree, ".orbita")) || fs6.existsSync(path6.join(worktree, ".nomadwork")) || fs6.existsSync(path6.join(worktree, ".nomadworks"));
+  return fs6.existsSync(path7.join(worktree, ".staticeng")) || fs6.existsSync(path7.join(worktree, ".orbita")) || fs6.existsSync(path7.join(worktree, ".nomadwork")) || fs6.existsSync(path7.join(worktree, ".nomadworks"));
 }
 function rootOptimaArtifacts(worktree) {
   const artifacts = [
-    ["tasks/", path6.join(worktree, "tasks")],
-    ["evidences/", path6.join(worktree, "evidences")],
-    ["docs/scrs/", path6.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path6.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path6.join(worktree, "codemap.yaml")]
+    ["tasks/", path7.join(worktree, "tasks")],
+    ["evidences/", path7.join(worktree, "evidences")],
+    ["docs/scrs/", path7.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path7.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path7.join(worktree, "codemap.yaml")]
   ];
   return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs6.existsSync(item.path));
 }
@@ -13874,7 +14021,7 @@ function planOptimaMigration(worktree, dryRun) {
       ...overrides.map((file) => ({
         category: "override",
         action: dryRun ? "would_remove_after_backup" : "removed_after_backup",
-        path: path6.relative(worktree, file).split(path6.sep).join("/"),
+        path: path7.relative(worktree, file).split(path7.sep).join("/"),
         detail: "Remove implicit agent/policy override after host-level backup."
       }))
     ],
@@ -13922,7 +14069,7 @@ async function sanitizeHost(options = {}) {
   const overrides = repoStates.flatMap((state) => state.overrideFiles.map((file) => ({ repo: state.repo, file })));
   report.totals.overrideFiles = overrides.length;
   if (!dryRun && overrides.length > 0) {
-    const backupPath = path6.join(os2.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
+    const backupPath = path7.join(os2.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
     try {
       createZipBackup(overrides.map((item) => item.file), backupPath);
       report.backupPath = backupPath;
@@ -13951,7 +14098,7 @@ async function sanitizeHost(options = {}) {
         repairActions: state.plan.actions.length,
         repairSkipped: state.plan.skippedRepair === true,
         overrideFiles: state.overrideFiles.length,
-        overridePaths: state.overrideFiles.map((file) => path6.relative(state.repo, file).split(path6.sep).join("/")),
+        overridePaths: state.overrideFiles.map((file) => path7.relative(state.repo, file).split(path7.sep).join("/")),
         validation: validation ? validationStatus(validation) : "skipped",
         unresolved: state.plan.unresolved
       });