@defend-tech/opencode-optima 0.1.68 → 0.1.70

package/dist/sanitize_cli.js

@@ -109,17 +109,17 @@ var require_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    function visit_(key, node, visitor, path7) {
-      const ctrl = callVisitor(key, node, visitor, path7);
+    function visit_(key, node, visitor, path8) {
+      const ctrl = callVisitor(key, node, visitor, path8);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visit_(key, ctrl, visitor, path7);
+        replaceNode(key, path8, ctrl);
+        return visit_(key, ctrl, visitor, path8);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path8 = Object.freeze(path8.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = visit_(i, node.items[i], visitor, path7);
+            const ci = visit_(i, node.items[i], visitor, path8);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -130,13 +130,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = visit_("key", node.key, visitor, path7);
+          path8 = Object.freeze(path8.concat(node));
+          const ck = visit_("key", node.key, visitor, path8);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = visit_("value", node.value, visitor, path7);
+          const cv = visit_("value", node.value, visitor, path8);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -157,17 +157,17 @@ var require_visit = __commonJS({
     visitAsync.BREAK = BREAK;
     visitAsync.SKIP = SKIP;
     visitAsync.REMOVE = REMOVE;
-    async function visitAsync_(key, node, visitor, path7) {
-      const ctrl = await callVisitor(key, node, visitor, path7);
+    async function visitAsync_(key, node, visitor, path8) {
+      const ctrl = await callVisitor(key, node, visitor, path8);
       if (identity.isNode(ctrl) || identity.isPair(ctrl)) {
-        replaceNode(key, path7, ctrl);
-        return visitAsync_(key, ctrl, visitor, path7);
+        replaceNode(key, path8, ctrl);
+        return visitAsync_(key, ctrl, visitor, path8);
       }
       if (typeof ctrl !== "symbol") {
         if (identity.isCollection(node)) {
-          path7 = Object.freeze(path7.concat(node));
+          path8 = Object.freeze(path8.concat(node));
           for (let i = 0; i < node.items.length; ++i) {
-            const ci = await visitAsync_(i, node.items[i], visitor, path7);
+            const ci = await visitAsync_(i, node.items[i], visitor, path8);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -178,13 +178,13 @@ var require_visit = __commonJS({
             }
           }
         } else if (identity.isPair(node)) {
-          path7 = Object.freeze(path7.concat(node));
-          const ck = await visitAsync_("key", node.key, visitor, path7);
+          path8 = Object.freeze(path8.concat(node));
+          const ck = await visitAsync_("key", node.key, visitor, path8);
           if (ck === BREAK)
             return BREAK;
           else if (ck === REMOVE)
             node.key = null;
-          const cv = await visitAsync_("value", node.value, visitor, path7);
+          const cv = await visitAsync_("value", node.value, visitor, path8);
           if (cv === BREAK)
             return BREAK;
           else if (cv === REMOVE)
@@ -211,23 +211,23 @@ var require_visit = __commonJS({
       }
       return visitor;
     }
-    function callVisitor(key, node, visitor, path7) {
+    function callVisitor(key, node, visitor, path8) {
       if (typeof visitor === "function")
-        return visitor(key, node, path7);
+        return visitor(key, node, path8);
       if (identity.isMap(node))
-        return visitor.Map?.(key, node, path7);
+        return visitor.Map?.(key, node, path8);
       if (identity.isSeq(node))
-        return visitor.Seq?.(key, node, path7);
+        return visitor.Seq?.(key, node, path8);
       if (identity.isPair(node))
-        return visitor.Pair?.(key, node, path7);
+        return visitor.Pair?.(key, node, path8);
       if (identity.isScalar(node))
-        return visitor.Scalar?.(key, node, path7);
+        return visitor.Scalar?.(key, node, path8);
       if (identity.isAlias(node))
-        return visitor.Alias?.(key, node, path7);
+        return visitor.Alias?.(key, node, path8);
       return void 0;
     }
-    function replaceNode(key, path7, node) {
-      const parent = path7[path7.length - 1];
+    function replaceNode(key, path8, node) {
+      const parent = path8[path8.length - 1];
       if (identity.isCollection(parent)) {
         parent.items[key] = node;
       } else if (identity.isPair(parent)) {
@@ -835,10 +835,10 @@ var require_Collection = __commonJS({
     var createNode = require_createNode();
     var identity = require_identity();
     var Node = require_Node();
-    function collectionFromPath(schema, path7, value) {
+    function collectionFromPath(schema, path8, value) {
       let v = value;
-      for (let i = path7.length - 1; i >= 0; --i) {
-        const k = path7[i];
+      for (let i = path8.length - 1; i >= 0; --i) {
+        const k = path8[i];
         if (typeof k === "number" && Number.isInteger(k) && k >= 0) {
           const a = [];
           a[k] = v;
@@ -857,7 +857,7 @@ var require_Collection = __commonJS({
         sourceObjects: /* @__PURE__ */ new Map()
       });
     }
-    var isEmptyPath = (path7) => path7 == null || typeof path7 === "object" && !!path7[Symbol.iterator]().next().done;
+    var isEmptyPath = (path8) => path8 == null || typeof path8 === "object" && !!path8[Symbol.iterator]().next().done;
     var Collection = class extends Node.NodeBase {
       constructor(type, schema) {
         super(type);
@@ -887,11 +887,11 @@ var require_Collection = __commonJS({
        * be a Pair instance or a `{ key, value }` object, which may not have a key
        * that already exists in the map.
        */
-      addIn(path7, value) {
-        if (isEmptyPath(path7))
+      addIn(path8, value) {
+        if (isEmptyPath(path8))
           this.add(value);
         else {
-          const [key, ...rest] = path7;
+          const [key, ...rest] = path8;
           const node = this.get(key, true);
           if (identity.isCollection(node))
             node.addIn(rest, value);
@@ -905,8 +905,8 @@ var require_Collection = __commonJS({
        * Removes a value from the collection.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        const [key, ...rest] = path7;
+      deleteIn(path8) {
+        const [key, ...rest] = path8;
         if (rest.length === 0)
           return this.delete(key);
         const node = this.get(key, true);
@@ -920,8 +920,8 @@ var require_Collection = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        const [key, ...rest] = path7;
+      getIn(path8, keepScalar) {
+        const [key, ...rest] = path8;
         const node = this.get(key, true);
         if (rest.length === 0)
           return !keepScalar && identity.isScalar(node) ? node.value : node;
@@ -939,8 +939,8 @@ var require_Collection = __commonJS({
       /**
        * Checks if the collection includes a value with the key `key`.
        */
-      hasIn(path7) {
-        const [key, ...rest] = path7;
+      hasIn(path8) {
+        const [key, ...rest] = path8;
         if (rest.length === 0)
           return this.has(key);
         const node = this.get(key, true);
@@ -950,8 +950,8 @@ var require_Collection = __commonJS({
        * Sets a value in this collection. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        const [key, ...rest] = path7;
+      setIn(path8, value) {
+        const [key, ...rest] = path8;
         if (rest.length === 0) {
           this.set(key, value);
         } else {
@@ -3455,9 +3455,9 @@ var require_Document = __commonJS({
           this.contents.add(value);
       }
       /** Adds a value to the document. */
-      addIn(path7, value) {
+      addIn(path8, value) {
         if (assertCollection(this.contents))
-          this.contents.addIn(path7, value);
+          this.contents.addIn(path8, value);
       }
       /**
        * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
@@ -3532,14 +3532,14 @@ var require_Document = __commonJS({
        * Removes a value from the document.
        * @returns `true` if the item was found and removed.
        */
-      deleteIn(path7) {
-        if (Collection.isEmptyPath(path7)) {
+      deleteIn(path8) {
+        if (Collection.isEmptyPath(path8)) {
           if (this.contents == null)
             return false;
           this.contents = null;
           return true;
         }
-        return assertCollection(this.contents) ? this.contents.deleteIn(path7) : false;
+        return assertCollection(this.contents) ? this.contents.deleteIn(path8) : false;
       }
       /**
        * Returns item at `key`, or `undefined` if not found. By default unwraps
@@ -3554,10 +3554,10 @@ var require_Document = __commonJS({
        * scalar values from their surrounding node; to disable set `keepScalar` to
        * `true` (collections are always returned intact).
        */
-      getIn(path7, keepScalar) {
-        if (Collection.isEmptyPath(path7))
+      getIn(path8, keepScalar) {
+        if (Collection.isEmptyPath(path8))
           return !keepScalar && identity.isScalar(this.contents) ? this.contents.value : this.contents;
-        return identity.isCollection(this.contents) ? this.contents.getIn(path7, keepScalar) : void 0;
+        return identity.isCollection(this.contents) ? this.contents.getIn(path8, keepScalar) : void 0;
       }
       /**
        * Checks if the document includes a value with the key `key`.
@@ -3568,10 +3568,10 @@ var require_Document = __commonJS({
       /**
        * Checks if the document includes a value at `path`.
        */
-      hasIn(path7) {
-        if (Collection.isEmptyPath(path7))
+      hasIn(path8) {
+        if (Collection.isEmptyPath(path8))
           return this.contents !== void 0;
-        return identity.isCollection(this.contents) ? this.contents.hasIn(path7) : false;
+        return identity.isCollection(this.contents) ? this.contents.hasIn(path8) : false;
       }
       /**
        * Sets a value in this document. For `!!set`, `value` needs to be a
@@ -3588,13 +3588,13 @@ var require_Document = __commonJS({
        * Sets a value in this document. For `!!set`, `value` needs to be a
        * boolean to add/remove the item from the set.
        */
-      setIn(path7, value) {
-        if (Collection.isEmptyPath(path7)) {
+      setIn(path8, value) {
+        if (Collection.isEmptyPath(path8)) {
           this.contents = value;
         } else if (this.contents == null) {
-          this.contents = Collection.collectionFromPath(this.schema, Array.from(path7), value);
+          this.contents = Collection.collectionFromPath(this.schema, Array.from(path8), value);
         } else if (assertCollection(this.contents)) {
-          this.contents.setIn(path7, value);
+          this.contents.setIn(path8, value);
         }
       }
       /**
@@ -5546,9 +5546,9 @@ var require_cst_visit = __commonJS({
     visit.BREAK = BREAK;
     visit.SKIP = SKIP;
     visit.REMOVE = REMOVE;
-    visit.itemAtPath = (cst, path7) => {
+    visit.itemAtPath = (cst, path8) => {
       let item = cst;
-      for (const [field, index] of path7) {
+      for (const [field, index] of path8) {
         const tok = item?.[field];
         if (tok && "items" in tok) {
           item = tok.items[index];
@@ -5557,23 +5557,23 @@ var require_cst_visit = __commonJS({
       }
       return item;
     };
-    visit.parentCollection = (cst, path7) => {
-      const parent = visit.itemAtPath(cst, path7.slice(0, -1));
-      const field = path7[path7.length - 1][0];
+    visit.parentCollection = (cst, path8) => {
+      const parent = visit.itemAtPath(cst, path8.slice(0, -1));
+      const field = path8[path8.length - 1][0];
       const coll = parent?.[field];
       if (coll && "items" in coll)
         return coll;
       throw new Error("Parent collection not found");
     };
-    function _visit(path7, item, visitor) {
-      let ctrl = visitor(item, path7);
+    function _visit(path8, item, visitor) {
+      let ctrl = visitor(item, path8);
       if (typeof ctrl === "symbol")
         return ctrl;
       for (const field of ["key", "value"]) {
         const token = item[field];
         if (token && "items" in token) {
           for (let i = 0; i < token.items.length; ++i) {
-            const ci = _visit(Object.freeze(path7.concat([[field, i]])), token.items[i], visitor);
+            const ci = _visit(Object.freeze(path8.concat([[field, i]])), token.items[i], visitor);
             if (typeof ci === "number")
               i = ci - 1;
             else if (ci === BREAK)
@@ -5584,10 +5584,10 @@ var require_cst_visit = __commonJS({
             }
           }
           if (typeof ctrl === "function" && field === "key")
-            ctrl = ctrl(item, path7);
+            ctrl = ctrl(item, path8);
         }
       }
-      return typeof ctrl === "function" ? ctrl(item, path7) : ctrl;
+      return typeof ctrl === "function" ? ctrl(item, path8) : ctrl;
     }
     exports.visit = visit;
   }
@@ -7551,17 +7551,17 @@ var require_ignore = __commonJS({
     var throwError = (message, Ctor) => {
       throw new Ctor(message);
     };
-    var checkPath = (path7, originalPath, doThrow) => {
-      if (!isString(path7)) {
+    var checkPath = (path8, originalPath, doThrow) => {
+      if (!isString(path8)) {
         return doThrow(
           `path must be a string, but got \`${originalPath}\``,
           TypeError
         );
       }
-      if (!path7) {
+      if (!path8) {
         return doThrow(`path must not be empty`, TypeError);
       }
-      if (checkPath.isNotRelative(path7)) {
+      if (checkPath.isNotRelative(path8)) {
         const r = "`path.relative()`d";
         return doThrow(
           `path should be a ${r} string, but got "${originalPath}"`,
@@ -7570,7 +7570,7 @@ var require_ignore = __commonJS({
       }
       return true;
     };
-    var isNotRelative = (path7) => REGEX_TEST_INVALID_PATH.test(path7);
+    var isNotRelative = (path8) => REGEX_TEST_INVALID_PATH.test(path8);
     checkPath.isNotRelative = isNotRelative;
     checkPath.convert = (p) => p;
     var Ignore = class {
@@ -7629,7 +7629,7 @@ var require_ignore = __commonJS({
       //   setting `checkUnignored` to `false` could reduce additional
       //   path matching.
       // @returns {TestResult} true if a file is ignored
-      _testOne(path7, checkUnignored) {
+      _testOne(path8, checkUnignored) {
         let ignored = false;
         let unignored = false;
         this._rules.forEach((rule) => {
@@ -7637,7 +7637,7 @@ var require_ignore = __commonJS({
           if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
             return;
           }
-          const matched = rule.regex.test(path7);
+          const matched = rule.regex.test(path8);
           if (matched) {
             ignored = !negative;
             unignored = negative;
@@ -7650,24 +7650,24 @@ var require_ignore = __commonJS({
       }
       // @returns {TestResult}
       _test(originalPath, cache, checkUnignored, slices) {
-        const path7 = originalPath && checkPath.convert(originalPath);
+        const path8 = originalPath && checkPath.convert(originalPath);
         checkPath(
-          path7,
+          path8,
           originalPath,
           this._allowRelativePaths ? RETURN_FALSE : throwError
         );
-        return this._t(path7, cache, checkUnignored, slices);
+        return this._t(path8, cache, checkUnignored, slices);
       }
-      _t(path7, cache, checkUnignored, slices) {
-        if (path7 in cache) {
-          return cache[path7];
+      _t(path8, cache, checkUnignored, slices) {
+        if (path8 in cache) {
+          return cache[path8];
         }
         if (!slices) {
-          slices = path7.split(SLASH);
+          slices = path8.split(SLASH);
         }
         slices.pop();
         if (!slices.length) {
-          return cache[path7] = this._testOne(path7, checkUnignored);
+          return cache[path8] = this._testOne(path8, checkUnignored);
         }
         const parent = this._t(
           slices.join(SLASH) + SLASH,
@@ -7675,24 +7675,24 @@ var require_ignore = __commonJS({
           checkUnignored,
           slices
         );
-        return cache[path7] = parent.ignored ? parent : this._testOne(path7, checkUnignored);
+        return cache[path8] = parent.ignored ? parent : this._testOne(path8, checkUnignored);
       }
-      ignores(path7) {
-        return this._test(path7, this._ignoreCache, false).ignored;
+      ignores(path8) {
+        return this._test(path8, this._ignoreCache, false).ignored;
       }
       createFilter() {
-        return (path7) => !this.ignores(path7);
+        return (path8) => !this.ignores(path8);
       }
       filter(paths) {
         return makeArray(paths).filter(this.createFilter());
       }
       // @returns {TestResult}
-      test(path7) {
-        return this._test(path7, this._testCache, true);
+      test(path8) {
+        return this._test(path8, this._testCache, true);
       }
     };
     var factory = (options) => new Ignore(options);
-    var isPathValid = (path7) => checkPath(path7 && checkPath.convert(path7), path7, RETURN_FALSE);
+    var isPathValid = (path8) => checkPath(path8 && checkPath.convert(path8), path8, RETURN_FALSE);
     factory.isPathValid = isPathValid;
     factory.default = factory;
     module.exports = factory;
@@ -7703,7 +7703,7 @@ var require_ignore = __commonJS({
       const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
       checkPath.convert = makePosix;
       const REGIX_IS_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-      checkPath.isNotRelative = (path7) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path7) || isNotRelative(path7);
+      checkPath.isNotRelative = (path8) => REGIX_IS_WINDOWS_PATH_ABSOLUTE.test(path8) || isNotRelative(path8);
     }
   }
 });
@@ -7711,7 +7711,7 @@ var require_ignore = __commonJS({
 // src/sanitize_cli.js
 import fs6 from "node:fs";
 import os2 from "node:os";
-import path6 from "node:path";
+import path7 from "node:path";
 import { execFileSync as execFileSync2, spawnSync } from "node:child_process";
 
 // src/index.js
@@ -7721,8 +7721,7 @@ import crypto from "node:crypto";
 import fs5 from "node:fs";
 import http from "node:http";
 import os from "node:os";
-import path5 from "node:path";
-import { fileURLToPath } from "node:url";
+import path6 from "node:path";
 import { tool } from "@opencode-ai/plugin/tool";
 
 // src/git_utils.js
@@ -8493,7 +8492,9 @@ async function optima_validate_logic(worktree) {
   };
 }
 
-// src/index.js
+// src/constants.js
+import path5 from "node:path";
+import { fileURLToPath } from "node:url";
 var PKG_ROOT = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "..");
 var BUNDLE_ASSETS_DIR = path5.join(PKG_ROOT, "assets");
 var BUNDLE_AGENTS_DIR = path5.join(BUNDLE_ASSETS_DIR, "agents");
@@ -8536,6 +8537,7 @@ 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_ASSIGNMENT_WATCHDOG_RUNNING_GRACE_MS = 15 * 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]";
@@ -8624,20 +8626,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);
@@ -8658,7 +8662,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);
@@ -8673,13 +8677,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, "");
@@ -9174,7 +9178,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 : [];
@@ -9198,12 +9202,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;
   }
@@ -9289,17 +9293,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;
   });
@@ -9307,8 +9311,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" };
@@ -9363,18 +9367,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;
@@ -9437,10 +9441,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) {
@@ -9449,14 +9453,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();
@@ -9606,7 +9610,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));
@@ -9622,40 +9626,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;
@@ -9668,25 +9672,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);
@@ -9729,32 +9733,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;
@@ -9820,6 +9824,10 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
       assignmentWatchdogIntervalMs: normalizeNonNegativeInteger(
         opencode.assignment_watchdog_interval_ms ?? opencode.assignmentWatchdogIntervalMs ?? raw.assignment_watchdog_interval_ms ?? raw.assignmentWatchdogIntervalMs,
         CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS
+      ),
+      assignmentWatchdogRunningGraceMs: normalizeNonNegativeInteger(
+        opencode.assignment_watchdog_running_grace_ms ?? opencode.assignmentWatchdogRunningGraceMs ?? raw.assignment_watchdog_running_grace_ms ?? raw.assignmentWatchdogRunningGraceMs,
+        CLICKUP_ASSIGNMENT_WATCHDOG_RUNNING_GRACE_MS
       )
     },
     openchamber: {
@@ -9853,7 +9861,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");
@@ -9911,7 +9919,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 });
@@ -9932,7 +9940,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 = "") {
@@ -10308,7 +10316,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 {
@@ -10775,6 +10783,22 @@ async function readOpenCodeSessionMessages(client, { sessionId, directory, limit
   if (directory) query.directory = directory;
   return normalizeOpenCodeSessionMessages(await client.session.messages({ path: { id: sessionId }, query }));
 }
+async function readOpenCodeChildSessions(client, { sessionId, directory } = {}) {
+  if (typeof client?.session?.children !== "function") return [];
+  const attempts = [
+    { path: { id: sessionId }, query: directory ? { directory } : {} },
+    { path: { sessionID: sessionId }, query: directory ? { directory } : {} },
+    { sessionID: sessionId, ...directory ? { directory } : {} }
+  ];
+  for (const attempt of attempts) {
+    try {
+      const result = await client.session.children(attempt);
+      return normalizeOpenCodeSessionCollection(result?.data ?? result);
+    } catch {
+    }
+  }
+  return [];
+}
 function openCodeResultSummary(result) {
   const data = result?.data ?? result;
   return {
@@ -10835,13 +10859,28 @@ function openCodeMessageTimestampMs(message = {}, key = "updated") {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? number : 0;
 }
-function isOpenCodeAssistantMessageRunning(message = {}) {
+function openCodeSessionTimestampMs(session = {}, key = "updated") {
+  const time = session?.time || session?.info?.time || {};
+  const value = key === "created" ? session.time_created ?? session.timeCreated ?? time.created : session.time_updated ?? session.timeUpdated ?? time.updated ?? session.time_created ?? session.timeCreated ?? time.created;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function openCodeNowMs(now = /* @__PURE__ */ new Date()) {
+  const value = typeof now === "function" ? now() : now;
+  const number = Number(value instanceof Date ? value.getTime() : new Date(value).getTime());
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function isOpenCodeAssistantMessageRunning(message = {}, { latestActivityAt = 0, now = /* @__PURE__ */ new Date(), runningGraceMs = CLICKUP_ASSIGNMENT_WATCHDOG_RUNNING_GRACE_MS } = {}) {
   if (normalizeLooseToken(normalizeOpenCodeMessageRole(message)) !== "assistant") return false;
   const started = openCodeMessageTimestampMs(message, "created") > 0;
   if (!started) return false;
-  return openCodeMessageTimestampMs(message, "completed") === 0;
+  if (openCodeMessageTimestampMs(message, "completed") !== 0) return false;
+  const nowMs = openCodeNowMs(now);
+  const activityAt = Number(latestActivityAt) || openCodeMessageTimestampMs(message, "updated") || openCodeMessageTimestampMs(message, "created");
+  if (!Number.isFinite(nowMs) || nowMs <= 0 || !Number.isFinite(activityAt) || activityAt <= 0) return false;
+  return nowMs - activityAt <= Math.max(0, Number(runningGraceMs) || 0);
 }
-async function inspectOpenCodeSessionActivity(client, { sessionId, directory, limit = 10 } = {}) {
+async function inspectOpenCodeSessionActivity(client, { sessionId, directory, limit = 10, now = /* @__PURE__ */ new Date(), runningGraceMs = CLICKUP_ASSIGNMENT_WATCHDOG_RUNNING_GRACE_MS } = {}) {
   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) => ({
@@ -10851,20 +10890,45 @@ async function inspectOpenCodeSessionActivity(client, { sessionId, directory, li
     createdAt: openCodeMessageTimestampMs(message, "created"),
     completedAt: openCodeMessageTimestampMs(message, "completed")
   })).sort((a, b) => a.sortTime - b.sortTime || a.index - b.index);
+  const childSessions = await readOpenCodeChildSessions(client, { sessionId, directory });
+  const childActivities = childSessions.map((session, index) => ({
+    session,
+    index,
+    id: session.id || session.sessionID || session.sessionId || null,
+    agent: session.agent || session.mode?.agent || session.metadata?.agent || "",
+    updatedAt: openCodeSessionTimestampMs(session, "updated")
+  })).filter((entry) => entry.updatedAt > 0).sort((a, b) => a.updatedAt - b.updatedAt || 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;
+  const latestChild = childActivities.at(-1) || null;
+  const latestMessageActivityAt = latest?.sortTime || 0;
+  const latestChildActivityAt = latestChild?.updatedAt || 0;
+  const latestActivityAt = Math.max(latestMessageActivityAt, latestChildActivityAt);
+  const nowMs = openCodeNowMs(now);
+  const latestActivityAgeMs = Number.isFinite(nowMs) && latestActivityAt > 0 ? Math.max(0, nowMs - latestActivityAt) : null;
+  const assistantRunning = latestAssistant ? isOpenCodeAssistantMessageRunning(latestAssistant.message, { latestActivityAt, now, runningGraceMs }) : false;
+  const childRunning = latestChildActivityAt > 0 && latestActivityAgeMs !== null && latestActivityAgeMs <= Math.max(0, Number(runningGraceMs) || 0);
+  const running = assistantRunning || childRunning;
+  const runningReason = running ? childRunning && latestChildActivityAt >= latestMessageActivityAt ? "recent_child_session_activity" : "recent_incomplete_assistant" : latestAssistant && latestAssistant.completedAt === 0 ? "stale_incomplete_assistant" : "not_running";
   return {
     ok: true,
     sessionId,
     directory,
     count: messages.length,
     running,
+    runningReason,
+    runningGraceMs,
+    latestActivityAt,
+    latestActivityAgeMs,
     latestMessageId: latest ? normalizeOpenCodeMessageId(latest.message) : null,
     latestAssistantMessageId: latestAssistant ? normalizeOpenCodeMessageId(latestAssistant.message) : null,
     latestAssistantCreatedAt: latestAssistant?.createdAt || 0,
-    latestAssistantCompletedAt: latestAssistant?.completedAt || 0
+    latestAssistantCompletedAt: latestAssistant?.completedAt || 0,
+    latestChildSessionId: latestChild?.id || null,
+    latestChildAgent: latestChild?.agent || null,
+    latestChildUpdatedAt: latestChild?.updatedAt || 0,
+    childSessionCount: childSessions.length
   };
 }
 function summarizeOpenCodeMessages(messages = [], { snippetLength = 160, maxMessages = 50 } = {}) {
@@ -11171,7 +11235,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");
@@ -11202,7 +11266,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();
@@ -11307,8 +11371,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 || ""));
@@ -11624,7 +11688,12 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       const directory = String(getNestedMetadataValue(metadata, "task.worktree") || "").trim();
       if (sessionId) {
         try {
-          const activity = await inspectOpenCodeSessionActivity(openCodeClient, { sessionId, directory });
+          const activity = await inspectOpenCodeSessionActivity(openCodeClient, {
+            sessionId,
+            directory,
+            now,
+            runningGraceMs: config.opencode.assignmentWatchdogRunningGraceMs
+          });
           appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity", taskId, sessionId, directory: directory || null, ...activity });
           if (activity.running) {
             routed.ignored += 1;
@@ -11919,17 +11988,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,
@@ -11948,12 +12017,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");
@@ -11988,14 +12057,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;
@@ -12003,9 +12072,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
       );
     }
@@ -12015,7 +12084,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"));
@@ -12027,51 +12096,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);
   }
@@ -12120,7 +12189,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");
@@ -12165,18 +12234,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);
@@ -12187,11 +12256,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,
@@ -12216,11 +12285,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) {
@@ -12303,15 +12372,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;
@@ -12414,11 +12483,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;
 }
@@ -12437,7 +12506,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];
@@ -12445,7 +12514,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) {
@@ -12517,7 +12586,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 = [
       "<!--",
@@ -12529,18 +12598,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() {
@@ -12627,13 +12696,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");
@@ -12652,9 +12721,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);
 }
@@ -12663,10 +12732,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);
@@ -12828,12 +12897,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);
@@ -12845,7 +12914,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;
   }
@@ -12853,15 +12922,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,
@@ -12895,8 +12964,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;
@@ -12905,7 +12974,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}
 
@@ -12958,7 +13027,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()}
@@ -13110,8 +13179,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.";
         }
@@ -13233,14 +13302,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
@@ -13319,12 +13388,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"
@@ -13523,7 +13592,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);
@@ -13575,7 +13644,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 });
@@ -13760,13 +13829,13 @@ function usage() {
 }
 function expandHome(inputPath) {
   if (!inputPath || inputPath === "~") return os2.homedir();
-  if (inputPath.startsWith("~/")) return path6.join(os2.homedir(), inputPath.slice(2));
+  if (inputPath.startsWith("~/")) return path7.join(os2.homedir(), inputPath.slice(2));
   return inputPath;
 }
 function resolveOpenCodeDbPath(inputPath = null) {
   const expanded = expandHome(inputPath || process.env.OPTIMA_OPENCODE_DB_PATH || DEFAULT_DB_PATH);
   try {
-    if (fs6.existsSync(expanded) && fs6.statSync(expanded).isDirectory()) return path6.join(expanded, "opencode.db");
+    if (fs6.existsSync(expanded) && fs6.statSync(expanded).isDirectory()) return path7.join(expanded, "opencode.db");
   } catch {
     return expanded;
   }
@@ -13830,8 +13899,8 @@ function extractOpenedPathValue(value) {
 }
 function normalizePathCandidate(candidate) {
   const expanded = expandHome(candidate);
-  if (!path6.isAbsolute(expanded)) return null;
-  return path6.resolve(expanded);
+  if (!path7.isAbsolute(expanded)) return null;
+  return path7.resolve(expanded);
 }
 function discoverOpenCodePaths(dbPath) {
   const resolvedDb = resolveOpenCodeDbPath(dbPath);
@@ -13860,27 +13929,27 @@ function discoverOpenCodePaths(dbPath) {
 function collectMarkdownOverridesFrom(baseDir) {
   const files = [];
   for (const dirName of OVERRIDE_DIRS) {
-    const dirPath = path6.join(baseDir, dirName);
+    const dirPath = path7.join(baseDir, dirName);
     if (!fs6.existsSync(dirPath)) continue;
     for (const entry of fs6.readdirSync(dirPath, { withFileTypes: true })) {
       if (!entry.isFile()) continue;
       if (!entry.name.endsWith(".md")) continue;
       if (entry.name.toLowerCase() === "readme.md") continue;
-      files.push(path6.join(dirPath, entry.name));
+      files.push(path7.join(dirPath, entry.name));
     }
   }
   return files;
 }
 function collectOverrideFiles(worktree) {
-  return collectMarkdownOverridesFrom(path6.join(worktree, ".optima")).sort();
+  return collectMarkdownOverridesFrom(path7.join(worktree, ".optima")).sort();
 }
 function collectPlannedOverrideFiles(worktree) {
   return [
     ...collectOverrideFiles(worktree),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".staticeng")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".orbita")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".nomadwork")),
-    ...collectMarkdownOverridesFrom(path6.join(worktree, ".nomadworks"))
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".staticeng")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".orbita")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadwork")),
+    ...collectMarkdownOverridesFrom(path7.join(worktree, ".nomadworks"))
   ].sort();
 }
 var CRC_TABLE = (() => {
@@ -13913,14 +13982,14 @@ function writeUInt16LE(value) {
   return buffer;
 }
 function createZipBackup(files, backupPath) {
-  fs6.mkdirSync(path6.dirname(backupPath), { recursive: true });
+  fs6.mkdirSync(path7.dirname(backupPath), { recursive: true });
   const localParts = [];
   const centralParts = [];
   let offset = 0;
   const now = dosTimeDate();
   for (const filePath of files) {
     const data = fs6.readFileSync(filePath);
-    const name = path6.resolve(filePath).replace(/^\//, "").split(path6.sep).join("/");
+    const name = path7.resolve(filePath).replace(/^\//, "").split(path7.sep).join("/");
     const nameBuffer = Buffer.from(name, "utf8");
     const crc = crc32(data);
     const local = Buffer.concat([
@@ -13982,15 +14051,15 @@ function validationStatus(result) {
   return result.ok ? "passed" : "failed";
 }
 function hasLegacyMarker(worktree) {
-  return fs6.existsSync(path6.join(worktree, ".staticeng")) || fs6.existsSync(path6.join(worktree, ".orbita")) || fs6.existsSync(path6.join(worktree, ".nomadwork")) || fs6.existsSync(path6.join(worktree, ".nomadworks"));
+  return fs6.existsSync(path7.join(worktree, ".staticeng")) || fs6.existsSync(path7.join(worktree, ".orbita")) || fs6.existsSync(path7.join(worktree, ".nomadwork")) || fs6.existsSync(path7.join(worktree, ".nomadworks"));
 }
 function rootOptimaArtifacts(worktree) {
   const artifacts = [
-    ["tasks/", path6.join(worktree, "tasks")],
-    ["evidences/", path6.join(worktree, "evidences")],
-    ["docs/scrs/", path6.join(worktree, "docs", "scrs")],
-    ["codemap.yml", path6.join(worktree, "codemap.yml")],
-    ["codemap.yaml", path6.join(worktree, "codemap.yaml")]
+    ["tasks/", path7.join(worktree, "tasks")],
+    ["evidences/", path7.join(worktree, "evidences")],
+    ["docs/scrs/", path7.join(worktree, "docs", "scrs")],
+    ["codemap.yml", path7.join(worktree, "codemap.yml")],
+    ["codemap.yaml", path7.join(worktree, "codemap.yaml")]
   ];
   return artifacts.map(([display, artifactPath]) => ({ display, path: artifactPath })).filter((item) => fs6.existsSync(item.path));
 }
@@ -14018,7 +14087,7 @@ function planOptimaMigration(worktree, dryRun) {
       ...overrides.map((file) => ({
         category: "override",
         action: dryRun ? "would_remove_after_backup" : "removed_after_backup",
-        path: path6.relative(worktree, file).split(path6.sep).join("/"),
+        path: path7.relative(worktree, file).split(path7.sep).join("/"),
         detail: "Remove implicit agent/policy override after host-level backup."
       }))
     ],
@@ -14066,7 +14135,7 @@ async function sanitizeHost(options = {}) {
   const overrides = repoStates.flatMap((state) => state.overrideFiles.map((file) => ({ repo: state.repo, file })));
   report.totals.overrideFiles = overrides.length;
   if (!dryRun && overrides.length > 0) {
-    const backupPath = path6.join(os2.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
+    const backupPath = path7.join(os2.homedir(), BACKUP_DIRNAME, `${timestamp()}.zip`);
     try {
       createZipBackup(overrides.map((item) => item.file), backupPath);
       report.backupPath = backupPath;
@@ -14095,7 +14164,7 @@ async function sanitizeHost(options = {}) {
         repairActions: state.plan.actions.length,
         repairSkipped: state.plan.skippedRepair === true,
         overrideFiles: state.overrideFiles.length,
-        overridePaths: state.overrideFiles.map((file) => path6.relative(state.repo, file).split(path6.sep).join("/")),
+        overridePaths: state.overrideFiles.map((file) => path7.relative(state.repo, file).split(path7.sep).join("/")),
         validation: validation ? validationStatus(validation) : "skipped",
         unresolved: state.plan.unresolved
       });