@defend-tech/opencode-optima 0.1.67 → 0.1.69

package/dist/index.js

@@ -108,17 +108,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path6) {
-      const ctrl = callVisitor(key, node, visitor, path6);
+    function visit_(key, node, visitor, path7) {
+      const ctrl = callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path6, ctrl);
-        return visit_(key, ctrl, visitor, path6);
+        replaceNode(key, path7, ctrl);
+        return visit_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path6 = Object.freeze(path6.concat(node));
+          path7 = Object.freeze(path7.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path6);
+            const ci = visit_(i, node.items[i], visitor, path7);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -129,13 +129,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path6 = Object.freeze(path6.concat(node));
-          const ck = visit_("key", node.key, visitor, path6);
+          path7 = Object.freeze(path7.concat(node));
+          const ck = visit_("key", node.key, visitor, path7);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path6);
+          const cv = visit_("value", node.value, visitor, path7);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -156,17 +156,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path6) {
-      const ctrl = await callVisitor(key, node, visitor, path6);
+    async function visitAsync_(key, node, visitor, path7) {
+      const ctrl = await callVisitor(key, node, visitor, path7);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path6, ctrl);
-        return visitAsync_(key, ctrl, visitor, path6);
+        replaceNode(key, path7, ctrl);
+        return visitAsync_(key, ctrl, visitor, path7);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path6 = Object.freeze(path6.concat(node));
+          path7 = Object.freeze(path7.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path6);
+            const ci = await visitAsync_(i, node.items[i], visitor, path7);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -177,13 +177,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path6 = Object.freeze(path6.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path6);
+          path7 = Object.freeze(path7.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path7);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path6);
+          const cv = await visitAsync_("value", node.value, visitor, path7);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -210,23 +210,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path6) {
+    function callVisitor(key, node, visitor, path7) {
       if (typeof visitor === "function")
-        return visitor(key, node, path6);
+        return visitor(key, node, path7);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path6);
+        return visitor.Map?.(key, node, path7);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path6);
+        return visitor.Seq?.(key, node, path7);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path6);
+        return visitor.Pair?.(key, node, path7);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path6);
+        return visitor.Scalar?.(key, node, path7);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path6);
+        return visitor.Alias?.(key, node, path7);
       return void 0;
     }
-    function replaceNode(key, path6, node) {
-      const parent = path6[path6.length - 1];
+    function replaceNode(key, path7, node) {
+      const parent = path7[path7.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -834,10 +834,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path6, value) {
+    function collectionFromPath(schema, path7, value) {
       let v = value;
-      for (let i = path6.length - 1; i >= 0; --i) {
-        const k = path6[i];
+      for (let i = path7.length - 1; i >= 0; --i) {
+        const k = path7[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -856,7 +856,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path6) => path6 == null || typeof path6 === "object" && !!path6[Symbol.iterator]().next().done;
+    var isEmptyPath = (path7) => path7 == null || typeof path7 === "object" && !!path7[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -886,11 +886,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(path6, value) {
-        if (isEmptyPath(path6))
+      addIn(path7, value) {
+        if (isEmptyPath(path7))
           this.add(value);
         else {
-          const [key, ...rest] = path6;
+          const [key, ...rest] = path7;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -904,8 +904,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path6) {
-        const [key, ...rest] = path6;
+      deleteIn(path7) {
+        const [key, ...rest] = path7;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -919,8 +919,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path6, keepScalar) {
-        const [key, ...rest] = path6;
+      getIn(path7, keepScalar) {
+        const [key, ...rest] = path7;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -938,8 +938,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path6) {
-        const [key, ...rest] = path6;
+      hasIn(path7) {
+        const [key, ...rest] = path7;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -949,8 +949,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(path6, value) {
-        const [key, ...rest] = path6;
+      setIn(path7, value) {
+        const [key, ...rest] = path7;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3454,9 +3454,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path6, value) {
+      addIn(path7, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path6, value);
+          this.contents.addIn(path7, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3531,14 +3531,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path6) {
-        if (Collection.isEmptyPath(path6)) {
+      deleteIn(path7) {
+        if (Collection.isEmptyPath(path7)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path6) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path7) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3553,10 +3553,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path6, keepScalar) {
-        if (Collection.isEmptyPath(path6))
+      getIn(path7, keepScalar) {
+        if (Collection.isEmptyPath(path7))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path6, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path7, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3567,10 +3567,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path6) {
-        if (Collection.isEmptyPath(path6))
+      hasIn(path7) {
+        if (Collection.isEmptyPath(path7))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path6) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path7) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3587,13 +3587,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(path6, value) {
-        if (Collection.isEmptyPath(path6)) {
+      setIn(path7, value) {
+        if (Collection.isEmptyPath(path7)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path6), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path6, value);
+          this.contents.setIn(path7, value);
         }
       }
       /**
@@ -5545,9 +5545,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path6) => {
+    visit.itemAtPath = (cst, path7) => {
       let item = cst;
-      for (const [field, index] of path6) {
+      for (const [field, index] of path7) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5556,23 +5556,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path6) => {
-      const parent = visit.itemAtPath(cst, path6.slice(0, -1));
-      const field = path6[path6.length - 1][0];
+    visit.parentCollection = (cst, path7) => {
+      const parent = visit.itemAtPath(cst, path7.slice(0, -1));
+      const field = path7[path7.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path6, item, visitor) {
-      let ctrl = visitor(item, path6);
+    function _visit(path7, item, visitor) {
+      let ctrl = visitor(item, path7);
       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(path6.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path7.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5583,10 +5583,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path6);
+            ctrl = ctrl(item, path7);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path6) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path7) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7550,17 +7550,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path6, originalPath, doThrow) => {
-      if (!isString(path6)) {
+    var checkPath = (path7, originalPath, doThrow) => {
+      if (!isString(path7)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path6) {
+      if (!path7) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path6)) {
+      if (checkPath.isNotRelative(path7)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -7569,7 +7569,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path6) => REGEX_TEST_INVALID_PATH.test(path6);
+    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7628,7 +7628,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path6, checkUnignored) {
+      _testOne(path7, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -7636,7 +7636,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path6);
+          const matched = rule.regex.test(path7);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7649,24 +7649,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path6 = originalPath && checkPath.convert(originalPath);
+        const path7 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path6,
+          path7,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path6, cache, checkUnignored, slices);
+        return this._t(path7, cache, checkUnignored, slices);
       }
-      _t(path6, cache, checkUnignored, slices) {
-        if (path6 in cache) {
-          return cache[path6];
+      _t(path7, cache, checkUnignored, slices) {
+        if (path7 in cache) {
+          return cache[path7];
         }
         if (!slices) {
-          slices = path6.split(SLASH);
+          slices = path7.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path6] = this._testOne(path6, checkUnignored);
+          return cache[path7] = this._testOne(path7, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7674,24 +7674,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path6] = parent.ignored ? parent : this._testOne(path6, checkUnignored);
+        return cache[path7] = parent.ignored ? parent : this._testOne(path7, checkUnignored);
       }
-      ignores(path6) {
-        return this._test(path6, this._ignoreCache, false).ignored;
+      ignores(path7) {
+        return this._test(path7, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path6) => !this.ignores(path6);
+        return (path7) => !this.ignores(path7);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path6) {
-        return this._test(path6, this._testCache, true);
+      test(path7) {
+        return this._test(path7, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path6) => checkPath(path6 && checkPath.convert(path6), path6, RETURN_FALSE);
+    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7702,7 +7702,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 = (path6) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path6) || isNotRelative(path6);
+      checkPath.isNotRelative = (path7) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
     }
   }
 });
@@ -7714,8 +7714,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
@@ -8486,7 +8485,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");
@@ -8527,6 +8528,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]";
@@ -8615,20 +8618,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);
@@ -8649,7 +8654,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);
@@ -8664,13 +8669,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, "");
@@ -9165,7 +9170,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 : [];
@@ -9189,12 +9194,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;
   }
@@ -9280,17 +9285,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;
   });
@@ -9298,8 +9303,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" };
@@ -9354,18 +9359,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;
@@ -9428,10 +9433,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) {
@@ -9440,14 +9445,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();
@@ -9597,7 +9602,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));
@@ -9613,40 +9618,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;
@@ -9659,25 +9664,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);
@@ -9720,32 +9725,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;
@@ -9807,6 +9812,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: {
@@ -9840,7 +9849,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");
@@ -9898,7 +9907,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 });
@@ -9919,7 +9928,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 = "") {
@@ -10295,7 +10304,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 {
@@ -10772,17 +10781,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) : [];
@@ -10922,8 +11001,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");
 }
@@ -11087,7 +11167,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");
@@ -11118,7 +11198,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();
@@ -11141,6 +11221,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" };
@@ -11154,10 +11235,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 });
@@ -11222,8 +11303,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 || ""));
@@ -11447,19 +11528,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 = "";
@@ -11477,6 +11593,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 });
@@ -11495,9 +11612,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,
@@ -11547,12 +11684,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;
@@ -11579,11 +11716,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) {
@@ -11778,17 +11915,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,
@@ -11807,12 +11944,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");
@@ -11847,14 +11984,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;
@@ -11862,9 +11999,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
       );
     }
@@ -11874,7 +12011,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"));
@@ -11886,51 +12023,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);
   }
@@ -11979,7 +12116,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");
@@ -12024,18 +12161,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);
@@ -12046,11 +12183,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,
@@ -12075,11 +12212,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) {
@@ -12162,15 +12299,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;
@@ -12273,11 +12410,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;
 }
@@ -12296,7 +12433,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];
@@ -12304,7 +12441,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) {
@@ -12376,7 +12513,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 = [
       "<!--",
@@ -12388,18 +12525,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() {
@@ -12486,13 +12623,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");
@@ -12511,9 +12648,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);
 }
@@ -12522,10 +12659,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);
@@ -12687,12 +12824,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);
@@ -12704,7 +12841,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;
   }
@@ -12712,15 +12849,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,
@@ -12754,8 +12891,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;
@@ -12764,7 +12901,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}
 
@@ -12817,7 +12954,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()}
@@ -12897,7 +13034,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,
@@ -12959,8 +13106,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.";
         }
@@ -13082,14 +13229,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
@@ -13168,12 +13315,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"
@@ -13372,7 +13519,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);
@@ -13424,7 +13571,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 });
@@ -13553,7 +13700,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 };
 export {
   OptimaPlugin as default
 };