@defend-tech/opencode-optima 0.1.58 → 0.1.60

package/dist/sanitize_cli.js

@@ -633,8 +633,6 @@ var require_Alias = __commonJS({
        * instance of the `source` anchor before this node.
        */
       resolve(doc, ctx) {
-        if (ctx?.maxAliasCount === 0)
-          throw new ReferenceError("Alias resolution is disabled");
         let nodes;
         if (ctx?.aliasResolveCache) {
           nodes = ctx.aliasResolveCache;
@@ -1434,7 +1432,6 @@ var require_stringify = __commonJS({
         nullStr: "null",
         simpleKeys: false,
         singleQuote: null,
-        trailingComma: false,
         trueStr: "true",
         verifyAliasOrder: true
       }, doc.schema.toStringOptions, options);
@@ -1707,18 +1704,18 @@ var require_merge = __commonJS({
     };
     var isMergeKey = (ctx, key) => (merge.identify(key) || identity.isScalar(key) && (!key.type || key.type === Scalar.Scalar.PLAIN) && merge.identify(key.value)) && ctx?.doc.schema.tags.some((tag) => tag.tag === merge.tag && tag.default);
     function addMergeToJSMap(ctx, map, value) {
-      const source = resolveAliasValue(ctx, value);
-      if (identity.isSeq(source))
-        for (const it of source.items)
+      value = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
+      if (identity.isSeq(value))
+        for (const it of value.items)
           mergeValue(ctx, map, it);
-      else if (Array.isArray(source))
-        for (const it of source)
+      else if (Array.isArray(value))
+        for (const it of value)
           mergeValue(ctx, map, it);
       else
-        mergeValue(ctx, map, source);
+        mergeValue(ctx, map, value);
     }
     function mergeValue(ctx, map, value) {
-      const source = resolveAliasValue(ctx, value);
+      const source = ctx && identity.isAlias(value) ? value.resolve(ctx.doc) : value;
       if (!identity.isMap(source))
         throw new Error("Merge sources must be maps or map aliases");
       const srcMap = source.toJSON(null, ctx, Map);
@@ -1739,9 +1736,6 @@ var require_merge = __commonJS({
       }
       return map;
     }
-    function resolveAliasValue(ctx, value) {
-      return ctx && identity.isAlias(value) ? value.resolve(ctx.doc, ctx) : value;
-    }
     exports.addMergeToJSMap = addMergeToJSMap;
     exports.isMergeKey = isMergeKey;
     exports.merge = merge;
@@ -1955,19 +1949,12 @@ ${indent}${line}` : "\n";
         if (comment)
           reqNewline = true;
         let str = stringify.stringify(item, itemCtx, () => comment = null);
-        reqNewline || (reqNewline = lines.length > linesAtValue || str.includes("\n"));
-        if (i < items.length - 1) {
+        if (i < items.length - 1)
           str += ",";
-        } else if (ctx.options.trailingComma) {
-          if (ctx.options.lineWidth > 0) {
-            reqNewline || (reqNewline = lines.reduce((sum, line) => sum + line.length + 2, 2) + (str.length + 2) > ctx.options.lineWidth);
-          }
-          if (reqNewline) {
-            str += ",";
-          }
-        }
         if (comment)
           str += stringifyComment.lineComment(str, itemIndent, commentString(comment));
+        if (!reqNewline && (lines.length > linesAtValue || str.includes("\n")))
+          reqNewline = true;
         lines.push(str);
         linesAtValue = lines.length;
       }
@@ -2379,7 +2366,7 @@ var require_stringifyNumber = __commonJS({
       if (!isFinite(num))
         return isNaN(num) ? ".nan" : num < 0 ? "-.inf" : ".inf";
       let n = Object.is(value, -0) ? "-0" : JSON.stringify(value);
-      if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^-?\d/.test(n) && !n.includes("e")) {
+      if (!format && minFractionDigits && (!tag || tag === "tag:yaml.org,2002:float") && /^\d/.test(n)) {
         let i = n.indexOf(".");
         if (i < 0) {
           i = n.length;
@@ -4751,7 +4738,7 @@ var require_resolve_flow_scalar = __commonJS({
             while (next === " " || next === "	")
               next = source[++i + 1];
           } else if (next === "x" || next === "u" || next === "U") {
-            const length = next === "x" ? 2 : next === "u" ? 4 : 8;
+            const length = { x: 2, u: 4, U: 8 }[next];
             res += parseCharCode(source, i + 1, length, onError);
             i += length;
           } else {
@@ -4826,13 +4813,12 @@ var require_resolve_flow_scalar = __commonJS({
       const cc = source.substr(offset, length);
       const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
       const code = ok ? parseInt(cc, 16) : NaN;
-      try {
-        return String.fromCodePoint(code);
-      } catch {
+      if (isNaN(code)) {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, "BAD_DQ_ESCAPE", `Invalid escape sequence ${raw}`);
         return raw;
       }
+      return String.fromCodePoint(code);
     }
     exports.resolveFlowScalar = resolveFlowScalar;
   }
@@ -4982,22 +4968,17 @@ var require_compose_node = __commonJS({
         case "block-map":
         case "block-seq":
         case "flow-collection":
-          try {
-            node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-            if (anchor)
-              node.anchor = anchor.source.substring(1);
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            onError(token, "RESOURCE_EXHAUSTION", message);
-          }
+          node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+          if (anchor)
+            node.anchor = anchor.source.substring(1);
           break;
         default: {
           const message = token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`;
           onError(token, "UNEXPECTED_TOKEN", message);
+          node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError);
           isSrcToken = false;
         }
       }
-      node ?? (node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError));
       if (anchor && node.anchor === "")
         onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
       if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) {
@@ -5182,10 +5163,8 @@ ${cb}` : comment;
           }
         }
         if (afterDoc) {
-          for (let i = 0; i < this.errors.length; ++i)
-            doc.errors.push(this.errors[i]);
-          for (let i = 0; i < this.warnings.length; ++i)
-            doc.warnings.push(this.warnings[i]);
+          Array.prototype.push.apply(doc.errors, this.errors);
+          Array.prototype.push.apply(doc.warnings, this.warnings);
         } else {
           doc.errors = this.errors;
           doc.warnings = this.warnings;
@@ -5918,7 +5897,7 @@ var require_lexer = __commonJS({
           const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
           this.indentNext = this.indentValue + 1;
           this.indentValue += n;
-          return "block-start";
+          return yield* this.parseBlockStart();
         }
         return "doc";
       }
@@ -6217,38 +6196,28 @@ var require_lexer = __commonJS({
         return 0;
       }
       *pushIndicators() {
-        let n = 0;
-        loop: while (true) {
-          switch (this.charAt(0)) {
-            case "!":
-              n += yield* this.pushTag();
-              n += yield* this.pushSpaces(true);
-              continue loop;
-            case "&":
-              n += yield* this.pushUntil(isNotAnchorChar);
-              n += yield* this.pushSpaces(true);
-              continue loop;
-            case "-":
-            // this is an error
-            case "?":
-            // this is an error outside flow collections
-            case ":": {
-              const inFlow = this.flowLevel > 0;
-              const ch1 = this.charAt(1);
-              if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
-                if (!inFlow)
-                  this.indentNext = this.indentValue + 1;
-                else if (this.flowKey)
-                  this.flowKey = false;
-                n += yield* this.pushCount(1);
-                n += yield* this.pushSpaces(true);
-                continue loop;
-              }
+        switch (this.charAt(0)) {
+          case "!":
+            return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+          case "&":
+            return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+          case "-":
+          // this is an error
+          case "?":
+          // this is an error outside flow collections
+          case ":": {
+            const inFlow = this.flowLevel > 0;
+            const ch1 = this.charAt(1);
+            if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
+              if (!inFlow)
+                this.indentNext = this.indentValue + 1;
+              else if (this.flowKey)
+                this.flowKey = false;
+              return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
             }
           }
-          break loop;
         }
-        return n;
+        return 0;
       }
       *pushTag() {
         if (this.charAt(1) === "<") {
@@ -6407,13 +6376,6 @@ var require_parser = __commonJS({
       }
       return prev.splice(i, prev.length);
     }
-    function arrayPushArray(target, source) {
-      if (source.length < 1e5)
-        Array.prototype.push.apply(target, source);
-      else
-        for (let i = 0; i < source.length; ++i)
-          target.push(source[i]);
-    }
     function fixFlowSeqItems(fc) {
       if (fc.start.type === "flow-seq-start") {
         for (const it of fc.items) {
@@ -6423,11 +6385,11 @@ var require_parser = __commonJS({
             delete it.key;
             if (isFlowToken(it.value)) {
               if (it.value.end)
-                arrayPushArray(it.value.end, it.sep);
+                Array.prototype.push.apply(it.value.end, it.sep);
               else
                 it.value.end = it.sep;
             } else
-              arrayPushArray(it.start, it.sep);
+              Array.prototype.push.apply(it.start, it.sep);
             delete it.sep;
           }
         }
@@ -6782,7 +6744,7 @@ var require_parser = __commonJS({
                 const prev = map.items[map.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  arrayPushArray(end, it.start);
+                  Array.prototype.push.apply(end, it.start);
                   end.push(this.sourceToken);
                   map.items.pop();
                   return;
@@ -6970,7 +6932,7 @@ var require_parser = __commonJS({
                 const prev = seq.items[seq.items.length - 2];
                 const end = prev?.value?.end;
                 if (Array.isArray(end)) {
-                  arrayPushArray(end, it.start);
+                  Array.prototype.push.apply(end, it.start);
                   end.push(this.sourceToken);
                   seq.items.pop();
                   return;
@@ -8848,7 +8810,13 @@ function deriveClickUpBranchName({ taskType, parentTaskId, subtaskId, taskId } =
     throw new Error("taskType and parentTaskId/taskId are required to derive a ClickUp branch name.");
   }
   if (typeSlug === "poc") return ["poc", parentSlug].join("/");
-  return [typeSlug, parentSlug, subtaskSlug].filter(Boolean).join("/");
+  if (subtaskSlug) return `${typeSlug}/${parentSlug}-subtask-${subtaskSlug}`;
+  return [typeSlug, parentSlug].join("/");
+}
+function isClickUpSubtaskRoute({ taskType, parentTaskId, subtaskId, taskId } = {}) {
+  return Boolean(
+    normalizeClickUpTaskType(taskType) !== "poc" && subtaskId && parentTaskId && String(parentTaskId) !== String(taskId || subtaskId)
+  );
 }
 function deriveClickUpPrTarget({ isRelease = false, parentTaskId, parentBranch, parentTaskType, taskType, devBranch = "dev", mainBranch = "main" } = {}) {
   if (isRelease) return mainBranch;
@@ -9037,15 +9005,17 @@ function deriveClickUpPendingSubtaskBranch({ taskType, parentTaskId, title } = {
   const parentSlug = branchSafeClickUpId(parentTaskId);
   if (!typeSlug || !parentSlug) throw new Error("taskType and parentTaskId are required to derive a pending subtask branch name.");
   if (typeSlug === "poc") return ["poc", parentSlug].join("/");
-  return [typeSlug, parentSlug, `pending-${normalizeLooseToken(title) || "subtask"}`].join("/");
+  return `${typeSlug}/${parentSlug}-pending-${normalizeLooseToken(title) || "subtask"}`;
 }
-function buildClickUpSubtaskAgentMetadata({ parentTaskId, subtask, branch, prTarget, titleSlug } = {}) {
+function buildClickUpSubtaskAgentMetadata({ parentTaskId, subtask, branch, prTarget, titleSlug, parentBranch } = {}) {
   return mergeClickUpAgentMetadata("", {
     subtask: {
       parent_task_id: parentTaskId,
+      parent_branch: parentBranch || prTarget,
       title: subtask.title,
       title_slug: titleSlug,
       branch,
+      subtask_branch: branch,
       pr_target: prTarget,
       pending_clickup_subtask_id: true,
       owner_role: subtask.ownerRole,
@@ -9065,7 +9035,7 @@ function buildClickUpCreateSubtasksPayload({ parentTaskId, markdown = "", source
     const titleSlug = normalizeLooseToken(subtask.title) || "subtask";
     const branch = subtask.branch || deriveClickUpPendingSubtaskBranch({ taskType: subtask.type, parentTaskId: parentId, title: subtask.title });
     const prTarget = normalizeClickUpTaskType(subtask.type) === "poc" ? "dev" : parentBranchValue;
-    const agentMetadata = buildClickUpSubtaskAgentMetadata({ parentTaskId: parentId, subtask, branch, prTarget, titleSlug });
+    const agentMetadata = buildClickUpSubtaskAgentMetadata({ parentTaskId: parentId, subtask, branch, prTarget, titleSlug, parentBranch: parentBranchValue });
     const descriptionParts = [
       subtask.description,
       subtask.acceptanceCriteria.length ? ["Acceptance Criteria:", ...subtask.acceptanceCriteria.map((item) => `- ${item}`)].join("\n") : ""
@@ -9243,27 +9213,261 @@ function safeExistingClickUpWorktree({ metadata = {}, branch = "" } = {}) {
     return null;
   }
 }
+function clickUpGitRefExists(baseWorktree, ref, runGitFn = runGit) {
+  try {
+    runGitFn(baseWorktree, ["rev-parse", "--verify", ref]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveClickUpDevStartPoint(baseWorktree, runGitFn = runGit) {
+  return clickUpGitRefExists(baseWorktree, "dev", runGitFn) ? "dev" : "origin/dev";
+}
+function addClickUpWorktreeForBranch({ baseWorktree, branch, worktreePath, startPoint, runGitFn = runGit } = {}) {
+  if (clickUpGitRefExists(baseWorktree, branch, runGitFn)) {
+    runGitFn(baseWorktree, ["worktree", "add", worktreePath, branch]);
+  } else {
+    runGitFn(baseWorktree, ["worktree", "add", "-b", branch, worktreePath, startPoint]);
+  }
+}
+function clickUpOpenChamberWorktreeName(branch = "") {
+  return String(branch || "").trim().replace(/\//g, "-");
+}
+function openChamberUrl(baseUrl, pathname, query = {}) {
+  const url = new URL(pathname, normalizeOpenCodeBaseUrl(baseUrl));
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0 && value !== null && String(value).trim()) url.searchParams.set(key, String(value));
+  }
+  return url.toString();
+}
+async function readOpenChamberJson(response, endpoint) {
+  const text = await response.text();
+  let data = null;
+  if (text.trim()) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`OpenChamber ${endpoint} returned non-JSON response.`);
+    }
+  }
+  if (!response.ok) {
+    const message = data?.error?.message || data?.message || data?.data?.message || text.slice(0, 200) || `HTTP ${response.status}`;
+    throw new Error(`OpenChamber ${endpoint} failed: ${response.status} ${message}`);
+  }
+  return data;
+}
+async function requestOpenChamberJson({ baseUrl, endpoint, method = "GET", directory, body, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof fetchImpl !== "function") throw new Error("OpenChamber worktree provisioning requires fetch.");
+  const response = await fetchImpl(openChamberUrl(baseUrl, endpoint, { directory }), {
+    method,
+    headers: body ? { "content-type": "application/json" } : void 0,
+    body: body ? JSON.stringify(body) : void 0
+  });
+  return readOpenChamberJson(response, endpoint);
+}
+function normalizeOpenChamberCollection(value) {
+  if (Array.isArray(value)) return value;
+  if (!isPlainObject(value)) return [];
+  for (const key of ["worktrees", "items", "data", "result", "results", "directories", "sandboxes"]) {
+    const nested = value[key];
+    if (Array.isArray(nested)) return nested;
+    if (isPlainObject(nested)) {
+      const normalized = normalizeOpenChamberCollection(nested);
+      if (normalized.length > 0) return normalized;
+    }
+  }
+  return [];
+}
+function openChamberEntryDirectory(entry) {
+  if (typeof entry === "string") return entry;
+  return String(entry?.directory || entry?.path || entry?.worktreePath || entry?.worktree_path || entry?.worktree?.path || entry?.worktree?.directory || "");
+}
+function openChamberEntryBranch(entry) {
+  if (typeof entry === "string") return "";
+  return String(entry?.branch || entry?.branchName || entry?.branch_name || entry?.worktree?.branch || "").replace(/^refs\/heads\//, "");
+}
+function openChamberListIncludesDirectory(list, directory) {
+  const resolved = path5.resolve(directory);
+  return normalizeOpenChamberCollection(list).some((entry) => {
+    const entryDirectory = openChamberEntryDirectory(entry);
+    return entryDirectory && path5.resolve(entryDirectory) === resolved;
+  });
+}
+function openChamberListIncludesBranch(list, directory, branch) {
+  const resolved = path5.resolve(directory);
+  return normalizeOpenChamberCollection(list).some((entry) => {
+    const entryDirectory = openChamberEntryDirectory(entry);
+    if (!entryDirectory || path5.resolve(entryDirectory) !== resolved) return false;
+    const entryBranch = openChamberEntryBranch(entry);
+    return !entryBranch || entryBranch === branch;
+  });
+}
+async function findOpenChamberProject({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  const projects = await requestOpenChamberJson({ baseUrl, 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;
+}
+async function refreshOpenChamberProjectCopy({ baseUrl, baseWorktree, projectId, fetchImpl = globalThis.fetch } = {}) {
+  if (!projectId) return { refreshed: false, reason: "project_id_unavailable" };
+  const response = await fetchImpl(openChamberUrl(baseUrl, `/experimental/project/${encodeURIComponent(projectId)}/copy/refresh`, {}), { method: "POST" });
+  await readOpenChamberJson(response, "/experimental/project/{projectID}/copy/refresh");
+  return { refreshed: true, projectId };
+}
+async function listOpenChamberGitWorktrees({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  return requestOpenChamberJson({ baseUrl, endpoint: "/api/git/worktrees", directory: baseWorktree, fetchImpl });
+}
+async function verifyOpenChamberGitWorktree({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const worktrees = await listOpenChamberGitWorktrees({ baseUrl, baseWorktree, fetchImpl });
+  const verified = openChamberListIncludesBranch(worktrees, worktreePath, branch);
+  if (!verified) {
+    throw new Error(`OpenChamber Git worktree verification failed for ${worktreePath} on ${branch}.`);
+  }
+  return { worktree: true, branch: true };
+}
+async function syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const gitWorktree = await verifyOpenChamberGitWorktree({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  await requestOpenChamberJson({ baseUrl, endpoint: "/experimental/workspace/sync-list", method: "POST", directory: baseWorktree, fetchImpl });
+  const project = await findOpenChamberProject({ baseUrl, baseWorktree, fetchImpl });
+  if (!project?.id) throw new Error("OpenChamber project was not found after workspace sync; refusing to treat worktree as visible.");
+  await refreshOpenChamberProjectCopy({ baseUrl, baseWorktree, projectId: project.id, fetchImpl });
+  const [worktrees, workspaces, directories] = await Promise.all([
+    listOpenChamberGitWorktrees({ baseUrl, baseWorktree, fetchImpl }),
+    requestOpenChamberJson({ baseUrl, endpoint: "/experimental/workspace", directory: baseWorktree, fetchImpl }),
+    requestOpenChamberJson({ baseUrl, endpoint: `/project/${encodeURIComponent(project.id)}/directories`, directory: baseWorktree, fetchImpl })
+  ]);
+  const visibility = {
+    worktree: openChamberListIncludesBranch(worktrees, worktreePath, branch),
+    workspace: openChamberListIncludesBranch(workspaces, worktreePath, branch),
+    projectDirectory: openChamberListIncludesDirectory(directories, worktreePath),
+    gitWorktree,
+    projectId: project.id
+  };
+  if (!visibility.worktree || !visibility.workspace || !visibility.projectDirectory) {
+    throw new Error(`OpenChamber visibility verification failed for ${worktreePath}: ${JSON.stringify(visibility)}`);
+  }
+  return visibility;
+}
+function assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath } = {}) {
+  if (!isClickUpDerivedWorktreeSibling(worktreePath, baseWorktree)) {
+    throw new Error(`OpenChamber worktree path is outside the configured ClickUp sibling scope: ${worktreePath}`);
+  }
+}
+async function createOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists = false, fetchImpl = globalThis.fetch } = {}) {
+  const worktreeName = clickUpOpenChamberWorktreeName(branch);
+  const body = { name: worktreeName, mode: branchExists ? "existing" : "new", worktreeName, branchName: branch, startRef: branchExists ? branch : startPoint };
+  let created;
+  try {
+    created = await requestOpenChamberJson({ baseUrl, endpoint: "/api/git/worktrees", method: "POST", directory: baseWorktree, body, fetchImpl });
+  } catch (error) {
+    throw new Error(`OpenChamber could not create ${branch} from ${branchExists ? branch : startPoint}; API may not support required branch/startRef semantics. Fail-closed: ${error.message}`);
+  }
+  const createdDirectory = openChamberEntryDirectory(created);
+  const createdBranch = openChamberEntryBranch(created);
+  if (!createdDirectory || !path5.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({ baseUrl, baseWorktree, worktreePath: createdDirectory, branch, fetchImpl });
+  return { created, worktree: path5.resolve(createdDirectory), branch: createdBranch, verified };
+}
+async function registerOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
+  assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath });
+  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  return { branch, worktree: path5.resolve(worktreePath), reused: true, provider: "openchamber", openChamber: { source, visibility } };
+}
+async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
+  const effectiveParent = parentTaskId || taskId;
+  const isSubtask = isClickUpSubtaskRoute({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
+  const parentBranch = isSubtask ? deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent }) : "";
+  const branch = deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
+  const prTarget = parentBranch || "dev";
+  const existing = safeExistingClickUpWorktree({ metadata: existingMetadata, branch });
+  if (existing) {
+    const registered = await registerOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch, worktreePath: existing.worktree, fetchImpl, source: "metadata_reuse" });
+    log?.({ type: "openchamber_worktree_registered", taskId, branch, worktree: registered.worktree, source: "metadata_reuse", visibility: registered.openChamber.visibility });
+    return { ...registered, parentBranch: parentBranch || void 0, prTarget };
+  }
+  const worktreePath = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
+  if (fs5.existsSync(worktreePath)) {
+    const registered = await registerOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch, worktreePath, fetchImpl, source: "existing_directory" });
+    log?.({ type: "openchamber_worktree_registered", taskId, branch, worktree: registered.worktree, source: "existing_directory", visibility: registered.openChamber.visibility });
+    return { ...registered, parentBranch: parentBranch || void 0, prTarget };
+  }
+  let parentBootstrap = null;
+  if (isSubtask) {
+    const parentWorktree = deriveClickUpWorktree({ baseWorktree, taskId: effectiveParent, taskType, parentTaskId: effectiveParent });
+    if (fs5.existsSync(parentWorktree)) {
+      const registeredParent = await registerOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, fetchImpl, source: "parent_existing_directory" });
+      parentBootstrap = { branch: parentBranch, worktree: registeredParent.worktree, reused: true, provider: "openchamber", visibility: registeredParent.openChamber.visibility };
+    } else {
+      const parentStartPoint = resolveClickUpDevStartPoint(baseWorktree, runGitFn);
+      const parentBranchExists = clickUpGitRefExists(baseWorktree, parentBranch, runGitFn);
+      const createdParent = await createOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, branchExists: parentBranchExists, fetchImpl });
+      const parentVisibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: createdParent.worktree, branch: parentBranch, fetchImpl });
+      parentBootstrap = { branch: parentBranch, worktree: createdParent.worktree, startPoint: parentBranchExists ? parentBranch : parentStartPoint, reused: parentBranchExists, provider: "openchamber", visibility: parentVisibility };
+      log?.({ type: "openchamber_worktree_created", taskId: effectiveParent, branch: parentBranch, worktree: parentBootstrap.worktree, startPoint: parentBootstrap.startPoint, visibility: parentVisibility });
+    }
+  }
+  const startPoint = isSubtask ? parentBranch : resolveClickUpDevStartPoint(baseWorktree, runGitFn);
+  const branchExists = clickUpGitRefExists(baseWorktree, branch, runGitFn);
+  const created = await createOpenChamberClickUpWorktree({ baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists, fetchImpl });
+  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: created.worktree, branch, fetchImpl });
+  log?.({ type: "openchamber_worktree_created", taskId, branch, worktree: created.worktree, startPoint: branchExists ? branch : startPoint, visibility });
+  return { branch, worktree: created.worktree, reused: false, startPoint, parentBranch: parentBranch || void 0, prTarget, parentBootstrap: parentBootstrap || void 0, provider: "openchamber", openChamber: { source: "created", visibility } };
+}
+async function ensureClickUpTaskWorktreeForWebhook({ opencodeBaseUrl = "", opencodeBaseUrlConfigured = false, openchamberBaseUrl = "", openchamberBaseUrlConfigured = false, clickupClient = null, webhookWorktree = process.cwd(), fetchImpl = globalThis.fetch, ...options } = {}) {
+  void opencodeBaseUrl;
+  void opencodeBaseUrlConfigured;
+  if (!openchamberBaseUrlConfigured || !openchamberBaseUrl) return ensureClickUpTaskWorktree(options);
+  try {
+    return await ensureClickUpTaskWorktreeOpenChamber({ ...options, baseUrl: openchamberBaseUrl, fetchImpl, log: (entry) => appendClickUpWebhookLocalLog(webhookWorktree, entry) });
+  } catch (error) {
+    const message = `OpenChamber worktree provisioning failed for ${options.taskId || "unknown task"}; raw git fallback is disabled to avoid invisible worktrees. ${error.message}`;
+    appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_failed", taskId: options.taskId || null, message });
+    if (typeof clickupClient?.postTaskComment === "function") {
+      try {
+        await clickupClient.postTaskComment({ taskId: options.taskId, comment: `${message}
+
+Optima did not run raw git worktree fallback. Please verify clickup.openchamber.base_url and OpenChamber Git API compatibility.` });
+      } catch (commentError) {
+        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_failed", taskId: options.taskId || null, message: commentError.message });
+      }
+    }
+    throw new Error(message);
+  }
+}
 function ensureClickUpTaskWorktree({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, allowNonGitFallback = false } = {}) {
   const effectiveParent = parentTaskId || taskId;
+  const isSubtask = isClickUpSubtaskRoute({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
+  const parentBranch = isSubtask ? deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent }) : "";
   const branch = deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
   const existing = safeExistingClickUpWorktree({ metadata: existingMetadata, branch });
-  if (existing) return { ...existing, 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 };
+  if (fs5.existsSync(worktreePath)) return { branch, worktree: path5.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" };
+    return { branch, worktree: path5.resolve(worktreePath), reused: false, fallback: "non_git", parentBranch: parentBranch || void 0, prTarget: parentBranch || "dev", startPoint: parentBranch || "dev" };
   }
-  const startPoint = (() => {
-    try {
-      runGitFn(baseWorktree, ["rev-parse", "--verify", "dev"]);
-      return "dev";
-    } catch {
-      return "origin/dev";
+  let parentBootstrap = null;
+  if (isSubtask) {
+    const parentWorktree = deriveClickUpWorktree({ baseWorktree, taskId: effectiveParent, taskType, parentTaskId: effectiveParent });
+    if (!fs5.existsSync(parentWorktree)) {
+      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 };
+    } else {
+      parentBootstrap = { branch: parentBranch, worktree: path5.resolve(parentWorktree), reused: true };
     }
-  })();
-  runGitFn(baseWorktree, ["worktree", "add", "-b", branch, worktreePath, startPoint]);
-  return { branch, worktree: path5.resolve(worktreePath), reused: false, startPoint };
+  }
+  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 };
 }
 function normalizeClickUpDefinitionDocParent(parent = {}) {
   const docId = String(parent.doc_id || parent.docId || CLICKUP_DEFINITION_DOC_PARENT.doc_id).trim();
@@ -9285,13 +9489,22 @@ function buildClickUpStartTaskPayload({ taskId, taskType = "Tarea", parentTaskId
   if (!description) errors.push("taskDescription is required for the initial ClickUp task description rewrite.");
   if (errors.length > 0) return clickUpPayloadValidationError(errors);
   const effectiveParent = parentTaskId || taskId;
+  const isSubtask = isClickUpSubtaskRoute({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
+  const parentBranch = isSubtask ? deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent }) : "";
   const branch = deriveClickUpBranchName({ taskType, parentTaskId: effectiveParent, subtaskId, taskId });
   const worktree = deriveClickUpWorktree({ baseWorktree, taskId, taskType, parentTaskId: effectiveParent, subtaskId });
+  const prTarget = isSubtask ? parentBranch : "dev";
+  const startFrom = isSubtask ? parentBranch : "dev";
   const estimate = preEstimateClickUpWork({ complexity, filesChanged, acceptanceCriteria, unknowns });
   const metadata = mergeClickUpAgentMetadata(existingAgentMetadata, {
     task: {
+      parent_task_id: isSubtask ? effectiveParent : void 0,
+      parent_branch: parentBranch || void 0,
       branch,
+      subtask_branch: isSubtask ? branch : void 0,
       worktree,
+      subtask_worktree: isSubtask ? worktree : void 0,
+      pr_target: prTarget,
       mirror_task_path: `.optima/tasks/${branchSafeClickUpId(taskId || subtaskId || effectiveParent)}.md`,
       evidence_path: `.optima/evidences/${branchSafeClickUpId(taskId || subtaskId || effectiveParent)}/SUMMARY.md`,
       delivery_evidence_path: deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent),
@@ -9304,17 +9517,18 @@ function buildClickUpStartTaskPayload({ taskId, taskType = "Tarea", parentTaskId
     dryRun: true,
     required_first_actions: [
       "Create or reuse the task-specific branch/worktree before planning or writing local .optima mirrors.",
-      `Use branch ${branch} from dev and worktree ${worktree} for this task workspace.`,
+      `Use branch ${branch} from ${startFrom} and worktree ${worktree} for this task workspace.`,
       "Write planning state, .optima/tasks/current.md, task mirrors, and local evidence only inside the task worktree.",
       `Write merge-trackable final evidence under ${deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent)}; .optima remains local mirror/staging.`,
       "Do not update the principal dev workspace .optima/tasks/current.md for ClickUp task planning.",
       "If another active task is present in current.md, move to or create this task worktree instead of stopping."
     ],
     git: {
-      startFrom: "dev",
+      startFrom,
       branch,
       worktree,
-      prTarget: subtaskId && normalizeClickUpTaskType(taskType) !== "poc" ? deriveClickUpPrTarget({ parentTaskId: effectiveParent, parentTaskType: taskType }) : "dev"
+      parentBranch: parentBranch || void 0,
+      prTarget
     },
     mirror: {
       taskPath: `.optima/tasks/${branchSafeClickUpId(taskId || subtaskId || effectiveParent)}.md`,
@@ -9326,7 +9540,7 @@ function buildClickUpStartTaskPayload({ taskId, taskType = "Tarea", parentTaskId
       wouldCreate: true
     },
     clickup: {
-      comment: `Starting task from dev. Branch: ${branch}. Worktree: ${worktree}. Delivery evidence: ${deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent)}.`,
+      comment: `Starting task from ${startFrom}. Branch: ${branch}. Worktree: ${worktree}. Delivery evidence: ${deliveryEvidencePathForClickUpTask(taskId || subtaskId || effectiveParent)}.`,
       description,
       fields: {
         Definition: definitionContent,
@@ -9587,6 +9801,11 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
   const webhook = isPlainObject(raw.webhook) ? raw.webhook : {};
   const routing = isPlainObject(raw.routing) ? raw.routing : {};
   const opencode = isPlainObject(raw.opencode) ? raw.opencode : {};
+  const openchamber = isPlainObject(raw.openchamber) ? raw.openchamber : {};
+  const rawOpenCodeBaseUrl = opencode.base_url ?? opencode.baseUrl ?? raw.opencode_base_url ?? raw.opencodeBaseUrl;
+  const rawOpenChamberBaseUrl = openchamber.base_url ?? openchamber.baseUrl ?? raw.openchamber_base_url ?? raw.openchamberBaseUrl;
+  const openCodeBaseUrlConfigured = rawOpenCodeBaseUrl !== void 0 && rawOpenCodeBaseUrl !== null && String(rawOpenCodeBaseUrl).trim() !== "";
+  const openChamberBaseUrlConfigured = rawOpenChamberBaseUrl !== void 0 && rawOpenChamberBaseUrl !== null && String(rawOpenChamberBaseUrl).trim() !== "";
   const location = isPlainObject(webhook.location) ? webhook.location : {};
   const events = Array.isArray(webhook.events) && webhook.events.length > 0 ? [...new Set(webhook.events.map((event) => String(event || "").trim()).filter(Boolean))] : [...CLICKUP_WEBHOOK_EVENTS];
   const ignoredStatuses = Array.isArray(routing.ignored_statuses) && routing.ignored_statuses.length > 0 ? routing.ignored_statuses : CLICKUP_WEBHOOK_TERMINAL_STATUSES;
@@ -9598,7 +9817,8 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
     apiToken: String(raw.api_token || raw.apiToken || "").trim(),
     log: normalizeClickUpWebhookLogLevel(raw.log),
     opencode: {
-      baseUrl: normalizeOpenCodeBaseUrl(opencode.base_url || opencode.baseUrl || raw.opencode_base_url || raw.opencodeBaseUrl),
+      baseUrl: normalizeOpenCodeBaseUrl(rawOpenCodeBaseUrl),
+      baseUrlConfigured: openCodeBaseUrlConfigured,
       promptDelivery: ["http", "direct"].includes(String(opencode.prompt_delivery || opencode.promptDelivery || raw.prompt_delivery || raw.promptDelivery || "").trim().toLowerCase()) ? "http" : "sdk",
       acceptPromptAdmission: opencode.accept_prompt_admission === true || opencode.acceptPromptAdmission === true || raw.accept_prompt_admission === true || raw.acceptPromptAdmission === true,
       startupReconciliationDelayMs: normalizeNonNegativeInteger(
@@ -9606,6 +9826,10 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
         CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS
       )
     },
+    openchamber: {
+      baseUrl: normalizeOpenCodeBaseUrl(rawOpenChamberBaseUrl, ""),
+      baseUrlConfigured: openChamberBaseUrlConfigured
+    },
     webhook: {
       publicUrl: String(webhook.public_url || webhook.publicUrl || "").trim(),
       bindHost: String(webhook.bind_host || webhook.bindHost || "127.0.0.1").trim(),
@@ -9647,6 +9871,13 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
       errors.push("clickup.opencode.base_url must be a valid URL");
     }
   }
+  if (config.openchamber.baseUrl) {
+    try {
+      new URL(config.openchamber.baseUrl);
+    } catch {
+      errors.push("clickup.openchamber.base_url must be a valid URL");
+    }
+  }
   const missingEvents = CLICKUP_WEBHOOK_EVENTS.filter((event) => !config.webhook.events.includes(event));
   if (missingEvents.length > 0) errors.push(`clickup.webhook.events missing: ${missingEvents.join(", ")}`);
   if (config.routing.targetAgent !== "workflow_product_manager") errors.push("clickup.routing.target_agent must be workflow_product_manager");
@@ -10570,6 +10801,16 @@ async function probeOpenCodeSessionControl(client, { directory, agent, omitAgent
   const rawMessages = await readOpenCodeSessionMessages(client, { sessionId: create.session_id, directory, limit: 50 });
   if (!rawMessages) throw new Error("OpenCode client does not expose session.messages.");
   const fullMessageText = rawMessages.map(openCodeMessageText).join("\n");
+  const respondingAgents = [...new Set(rawMessages.filter((message) => normalizeLooseToken(normalizeOpenCodeMessageRole(message)) === "assistant").flatMap((message) => [normalizeOpenCodeMessageAgent(message), normalizeOpenCodeMessageMode(message)]).map((value) => String(value || "").trim()).filter(Boolean))];
+  const requestedAgent = normalizeLooseToken(agent);
+  const assistantVisible = rawMessages.some((message) => normalizeLooseToken(normalizeOpenCodeMessageRole(message)) === "assistant");
+  const markerVisible = fullMessageText.includes(marker);
+  const deliveryVerified = markerVisible && assistantVisible;
+  const requestedAgentVerified = requestedAgent ? deliveryVerified && rawMessages.some((message) => {
+    const messageAgent = normalizeLooseToken(normalizeOpenCodeMessageAgent(message));
+    const messageMode = normalizeLooseToken(normalizeOpenCodeMessageMode(message));
+    return normalizeLooseToken(normalizeOpenCodeMessageRole(message)) === "assistant" && (messageAgent === requestedAgent || messageMode === requestedAgent);
+  }) : null;
   const messages = {
     ok: true,
     session_id: create.session_id,
@@ -10587,8 +10828,11 @@ async function probeOpenCodeSessionControl(client, { directory, agent, omitAgent
     marker_length: marker.length,
     marker_truncated: requestedMarker.length > marker.length,
     marker_hash: hashOpenCodeSessionText(marker),
-    marker_visible: fullMessageText.includes(marker),
-    assistant_visible: rawMessages.some((message) => normalizeLooseToken(normalizeOpenCodeMessageRole(message)) === "assistant" || Boolean(normalizeOpenCodeMessageAgent(message) && openCodeMessageText(message))),
+    marker_visible: markerVisible,
+    assistant_visible: assistantVisible,
+    delivery_verified: deliveryVerified,
+    requested_agent_verified: requestedAgentVerified,
+    responding_agents: respondingAgents,
     create,
     prompt,
     messages
@@ -10923,7 +11167,7 @@ async function withClickUpTaskRouteLock(taskId, operation) {
     if (activeClickUpTaskRoutes.get(key) === current) activeClickUpTaskRoutes.delete(key);
   }
 }
-async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktree, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
+async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktreeForWebhook, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
   const eventType = clickUpEventType(payload);
   const eventKey = clickUpWebhookEventKey(payload);
   const isStartupAssignmentReconciliation = payload?.startup_reconciliation === true && eventType === "taskAssigneeUpdated";
@@ -10979,7 +11223,7 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   const subtaskId = parentTaskId && parentTaskId !== taskId ? taskId : "";
   let taskRoute;
   try {
-    taskRoute = ensureTaskWorktree({ baseWorktree: config.basePath, taskId, taskType, parentTaskId, subtaskId, existingMetadata: metadata, allowNonGitFallback: process.env.NODE_ENV === "test" || config.test === true });
+    taskRoute = await ensureTaskWorktree({ baseWorktree: config.basePath, taskId, taskType, parentTaskId, subtaskId, existingMetadata: metadata, allowNonGitFallback: process.env.NODE_ENV === "test" || config.test === true, opencodeBaseUrl: config.opencode?.baseUrl, opencodeBaseUrlConfigured: config.opencode?.baseUrlConfigured === true, openchamberBaseUrl: config.openchamber?.baseUrl, openchamberBaseUrlConfigured: config.openchamber?.baseUrlConfigured === true, clickupClient, webhookWorktree: worktree });
   } catch (error) {
     const message = `Optima webhook could not create or reuse a task worktree for ${taskId}: ${error.message}`;
     appendClickUpWebhookLocalLog(worktree, { type: "task_worktree_failed", taskId, message });
@@ -10988,8 +11232,13 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   }
   const deliveryEvidencePath = deliveryEvidencePathForClickUpTask(taskId);
   const routingMetadata = {
+    parent_task_id: subtaskId ? parentTaskId : void 0,
+    parent_branch: taskRoute.parentBranch,
     branch: taskRoute.branch,
+    subtask_branch: subtaskId ? taskRoute.branch : void 0,
     worktree: taskRoute.worktree,
+    subtask_worktree: subtaskId ? taskRoute.worktree : void 0,
+    pr_target: taskRoute.prTarget || (subtaskId ? taskRoute.parentBranch : "dev"),
     delivery_evidence_path: deliveryEvidencePath,
     evidence_path: `.optima/evidences/${branchSafeClickUpId(taskId)}/SUMMARY.md`
   };
@@ -12261,7 +12510,33 @@ function getModePromptFragment(agentId, operatingTeamMode, worktree) {
 function shouldRegisterWorkflowProductManager(options = {}, worktree = process.cwd()) {
   if (options.clickUpWebhookActive === true) return true;
   const validation = options.clickUpWebhookValidation;
-  return validation?.complete === true && validation?.ok !== false && isSameOrNestedPath(worktree, validation.config?.basePath);
+  if (validation?.complete !== true || validation?.ok === false) return false;
+  const basePath = validation.config?.basePath;
+  return isSameOrNestedPath(worktree, basePath) || isClickUpDerivedWorktreeSibling(worktree, basePath);
+}
+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);
+  if (!candidateName.startsWith(`${baseName}-`)) return false;
+  const branchSlug = candidateName.slice(baseName.length + 1);
+  const parts = branchSlug.split("-").filter(Boolean);
+  if (parts.length < 2) return false;
+  if (!(/* @__PURE__ */ new Set(["tarea", "bug", "doc", "poc", "idea"])).has(parts[0])) return false;
+  if (!parts.slice(1).every((part) => /^[a-z0-9][a-z0-9-]*$/.test(part))) return false;
+  try {
+    const candidateStat = fs5.lstatSync(resolvedCandidate);
+    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;
+  } catch {
+    return false;
+  }
 }
 function resolveSessionToolDirectory({ requestedDirectory, context, pluginWorktree, clickUpWebhookValidation } = {}) {
   const safe = safeWorktreeOrFailure(context, pluginWorktree);
@@ -12273,6 +12548,9 @@ function resolveSessionToolDirectory({ requestedDirectory, context, pluginWorktr
   if (clickUpBasePath && isSameOrNestedPath(requested, clickUpBasePath)) {
     return { ok: true, directory: requested, safeWorktree: safe.worktree, scope: "clickup_base_path", clickupBasePath: path5.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: false,
     error: `Directory '${requested}' is outside the safe worktree '${safe.worktree}' and configured ClickUp base path.`
@@ -13104,7 +13382,7 @@ Follow-up: use optima_prompt_workflow with session_id '${sessionId}' to check in
     }
   };
 }
-OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, scheduleClickUpStartupReconciliation, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
+OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
 
 // src/sanitize_cli.js
 var { migrateLegacyOptimaLayout: migrateLegacyOptimaLayout2 } = OptimaPlugin.__internals;