@defend-tech/opencode-optima 0.1.59 → 0.1.61

package/assets/agents/workflow_product_manager.md

@@ -51,7 +51,9 @@ You are Workflow_Product_Manager, Optima's ClickUp-first delivery orchestrator.
 
 - Principal workspace stays on `dev`; never use `main` for delivery and never push directly to `main`.
 - Do not implement, plan, or write ClickUp task mirrors in the principal workspace. Use task-specific worktrees/branches.
-- To plan a ClickUp task, first create or reuse that task's branch/worktree with `optima_clickup_start_task`, then do Definition planning and local `.optima` mirror writes inside that task worktree.
+- To plan a ClickUp task, first create or reuse that task's branch/worktree with `optima_clickup_start_task`; webhook-created worktrees must be provisioned or registered through the configured OpenChamber Git API (`clickup.openchamber.base_url` `/api/git/worktrees`) before local `.optima` mirror writes.
+- Use `clickup.openchamber.base_url` only for OpenChamber Git worktree API calls; use `clickup.opencode.base_url` for OpenCode workspace/project sync, visibility checks, and session/prompt delivery.
+- If OpenChamber cannot create or verify the required branch/worktree (especially subtask start-from-parent semantics), fail closed with a ClickUp blocker comment instead of silently using raw `git worktree add`.
 - Do not update the principal `dev` workspace `.optima/tasks/current.md` for ClickUp task planning.
 - Unrelated active tasks in `.optima/tasks/current.md` must not block planning; move to/create the correct task worktree instead.
 - Parent setup pulls remote once; after parent branch creation, subtasks can trust the parent local branch without continuous remote polling.

package/dist/index.js

@@ -8527,6 +8527,7 @@ var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
 var CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT = 50;
 var CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT = 100;
 var CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS = 3e4;
+var CLICKUP_WORKTREE_FAILURE_COMMENT_DEDUPE_MS = 10 * 60 * 1e3;
 var CLICKUP_WEBHOOK_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "info", "verbose"]);
 var CLICKUP_WEBHOOK_REDACTED = "[REDACTED]";
 var DISCUSSION_BACKFILL_FETCH_LIMIT = 100;
@@ -9224,6 +9225,239 @@ function addClickUpWorktreeForBranch({ baseWorktree, branch, worktreePath, start
     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, serviceName = "OpenChamber") {
+  const text = await response.text();
+  let data = null;
+  if (text.trim()) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`${serviceName} ${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(`${serviceName} ${endpoint} failed: ${response.status} ${message}`);
+  }
+  return data;
+}
+async function requestServiceJson({ baseUrl, serviceName = "OpenChamber", endpoint, method = "GET", directory, body, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof fetchImpl !== "function") throw new Error(`${serviceName} API calls require 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, serviceName);
+}
+async function requestOpenChamberJson(options = {}) {
+  return requestServiceJson({ ...options, serviceName: "OpenChamber" });
+}
+async function requestOpenCodeJson(options = {}) {
+  return requestServiceJson({ ...options, serviceName: "OpenCode" });
+}
+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({ 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;
+}
+async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, projectId, fetchImpl = globalThis.fetch } = {}) {
+  if (!projectId) return { refreshed: false, reason: "project_id_unavailable" };
+  await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: `/experimental/project/${encodeURIComponent(projectId)}/copy/refresh`, method: "POST", fetchImpl });
+  return { refreshed: true, projectId };
+}
+async function listOpenChamberGitWorktrees({ openchamberBaseUrl, baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  return requestOpenChamberJson({ baseUrl: openchamberBaseUrl || baseUrl, endpoint: "/api/git/worktrees", directory: baseWorktree, fetchImpl });
+}
+async function verifyOpenChamberGitWorktree({ openchamberBaseUrl, baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const worktrees = await listOpenChamberGitWorktrees({ openchamberBaseUrl: openchamberBaseUrl || 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({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  const effectiveOpenCodeBaseUrl = opencodeBaseUrl || baseUrl;
+  const gitWorktree = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  await requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, endpoint: "/experimental/workspace/sync-list", method: "POST", directory: baseWorktree, fetchImpl });
+  const project = await findOpenChamberProject({ opencodeBaseUrl: effectiveOpenCodeBaseUrl, baseWorktree, fetchImpl });
+  if (!project?.id) throw new Error("OpenCode project was not found after workspace sync; refusing to treat worktree as visible.");
+  await refreshOpenChamberProjectCopy({ opencodeBaseUrl: effectiveOpenCodeBaseUrl, projectId: project.id, fetchImpl });
+  const [worktrees, workspaces, directories] = await Promise.all([
+    listOpenChamberGitWorktrees({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, fetchImpl }),
+    requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, endpoint: "/experimental/workspace", directory: baseWorktree, fetchImpl }),
+    requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, 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(`OpenCode 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({ openchamberBaseUrl, baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists = false, fetchImpl = globalThis.fetch } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  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: effectiveOpenChamberBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath: createdDirectory, branch, fetchImpl });
+  return { created, worktree: path5.resolve(createdDirectory), branch: createdBranch, verified };
+}
+async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
+  assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath });
+  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 } };
+}
+async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, openchamberBaseUrl = "", opencodeBaseUrl = "", baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  const effectiveOpenCodeBaseUrl = opencodeBaseUrl || baseUrl;
+  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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, branchExists: parentBranchExists, fetchImpl });
+      const parentVisibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists, fetchImpl });
+  const visibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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 opencodeBaseUrlConfigured;
+  if (!openchamberBaseUrlConfigured || !openchamberBaseUrl) return ensureClickUpTaskWorktree(options);
+  try {
+    return await ensureClickUpTaskWorktreeOpenChamber({ ...options, openchamberBaseUrl, opencodeBaseUrl, 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") {
+      const taskId = options.taskId || "unknown task";
+      const ledgerPath = clickUpCommentLedgerPath(webhookWorktree);
+      const comment = `${message}
+
+Optima did not run raw git worktree fallback. Please verify clickup.openchamber.base_url and OpenCode/OpenChamber endpoint configuration.`;
+      let dedupe = { post: true, key: clickUpWorktreeFailureCommentKey({ taskId, message }) };
+      try {
+        dedupe = shouldPostClickUpWorktreeFailureComment({ ledgerPath, taskId, message });
+      } catch (ledgerError) {
+        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_comment_dedupe_failed", taskId, message: ledgerError.message });
+      }
+      if (dedupe.post) {
+        try {
+          await clickupClient.postTaskComment({ taskId: options.taskId, comment });
+          recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted: true });
+        } catch (commentError) {
+          appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_failed", taskId: options.taskId || null, message: commentError.message });
+        }
+      } else {
+        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_deduped", taskId, key: dedupe.key, reason: dedupe.reason });
+        recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted: false, skippedReason: dedupe.reason });
+      }
+    }
+    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 });
@@ -9585,6 +9819,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;
@@ -9596,7 +9835,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(
@@ -9604,6 +9844,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(),
@@ -9645,6 +9889,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");
@@ -10001,23 +10252,29 @@ function rememberClickUpWebhookEvent(state = {}, eventKey, limit = 200) {
   if (recent.includes(eventKey)) return { duplicate: true, state };
   return { duplicate: false, state: { ...state, recentEventKeys: [...recent, eventKey].slice(-limit) } };
 }
-function readClickUpCommentLedger(ledgerPath) {
-  const processed = /* @__PURE__ */ new Set();
-  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return processed;
+function readClickUpCommentLedgerEntries(ledgerPath) {
+  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return [];
   try {
     const raw = fs5.readFileSync(ledgerPath, "utf8");
+    const entries = [];
     for (const [index, line] of raw.split(/\r?\n/).entries()) {
       if (!line.trim()) continue;
       try {
-        const entry = JSON.parse(line);
-        if (entry?.key) processed.add(String(entry.key));
+        entries.push(JSON.parse(line));
       } catch (error) {
         throw new Error(`malformed ledger row ${index + 1}: ${error.message}`);
       }
     }
+    return entries;
   } catch (error) {
     throw new Error(`ClickUp comment ledger unavailable: ${error.message}`);
   }
+}
+function readClickUpCommentLedger(ledgerPath) {
+  const processed = /* @__PURE__ */ new Set();
+  for (const entry of readClickUpCommentLedgerEntries(ledgerPath)) {
+    if (entry?.key) processed.add(String(entry.key));
+  }
   return processed;
 }
 function appendClickUpCommentLedgerEntry(ledgerPath, entry = {}) {
@@ -10083,6 +10340,35 @@ function recordClickUpCommentVersionProcessed({ ledgerPath, key, taskId, eventTy
     recordedAt: at.toISOString()
   });
 }
+function clickUpWorktreeFailureCommentKey({ taskId, message } = {}) {
+  const hash = crypto.createHash("sha256").update(String(message || "")).digest("hex").slice(0, 16);
+  return [String(taskId || "unknown").trim() || "unknown", "worktree_failure", hash].join(":");
+}
+function shouldPostClickUpWorktreeFailureComment({ ledgerPath, taskId, message, now = /* @__PURE__ */ new Date(), windowMs = CLICKUP_WORKTREE_FAILURE_COMMENT_DEDUPE_MS } = {}) {
+  const key = clickUpWorktreeFailureCommentKey({ taskId, message });
+  const nowMs = now instanceof Date ? now.getTime() : new Date(now).getTime();
+  for (const entry of readClickUpCommentLedgerEntries(ledgerPath).reverse()) {
+    if (entry?.key !== key) continue;
+    const postedAtMs = new Date(entry.postedAt || entry.recordedAt || entry.at || 0).getTime();
+    if (Number.isFinite(postedAtMs) && Number.isFinite(nowMs) && nowMs - postedAtMs <= windowMs) {
+      return { post: false, key, reason: "recent_duplicate" };
+    }
+    if (entry?.message === message) return { post: false, key, reason: "latest_equivalent" };
+  }
+  return { post: true, key };
+}
+function recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted = true, skippedReason = null, at = /* @__PURE__ */ new Date() } = {}) {
+  appendClickUpCommentLedgerEntry(ledgerPath, {
+    key: clickUpWorktreeFailureCommentKey({ taskId, message }),
+    taskId,
+    eventType: "worktree_failure",
+    action: posted ? "worktree_failure_comment_posted" : "worktree_failure_comment_skipped",
+    message,
+    posted,
+    skippedReason,
+    postedAt: at.toISOString()
+  });
+}
 function clickUpTaskIdFromPayload(payload = {}) {
   return String(payload.task_id || payload.taskId || payload.task?.id || payload.task?.task_id || "").trim();
 }
@@ -10934,7 +11220,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";
@@ -10990,7 +11276,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 });
@@ -13149,7 +13435,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, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, 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 };
 export {
   OptimaPlugin as default
 };

package/dist/sanitize_cli.js

@@ -8534,6 +8534,7 @@ var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
 var CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT = 50;
 var CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT = 100;
 var CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS = 3e4;
+var CLICKUP_WORKTREE_FAILURE_COMMENT_DEDUPE_MS = 10 * 60 * 1e3;
 var CLICKUP_WEBHOOK_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "info", "verbose"]);
 var CLICKUP_WEBHOOK_REDACTED = "[REDACTED]";
 var DISCUSSION_BACKFILL_FETCH_LIMIT = 100;
@@ -9231,6 +9232,239 @@ function addClickUpWorktreeForBranch({ baseWorktree, branch, worktreePath, start
     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, serviceName = "OpenChamber") {
+  const text = await response.text();
+  let data = null;
+  if (text.trim()) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`${serviceName} ${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(`${serviceName} ${endpoint} failed: ${response.status} ${message}`);
+  }
+  return data;
+}
+async function requestServiceJson({ baseUrl, serviceName = "OpenChamber", endpoint, method = "GET", directory, body, fetchImpl = globalThis.fetch } = {}) {
+  if (typeof fetchImpl !== "function") throw new Error(`${serviceName} API calls require 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, serviceName);
+}
+async function requestOpenChamberJson(options = {}) {
+  return requestServiceJson({ ...options, serviceName: "OpenChamber" });
+}
+async function requestOpenCodeJson(options = {}) {
+  return requestServiceJson({ ...options, serviceName: "OpenCode" });
+}
+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({ 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;
+}
+async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, projectId, fetchImpl = globalThis.fetch } = {}) {
+  if (!projectId) return { refreshed: false, reason: "project_id_unavailable" };
+  await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: `/experimental/project/${encodeURIComponent(projectId)}/copy/refresh`, method: "POST", fetchImpl });
+  return { refreshed: true, projectId };
+}
+async function listOpenChamberGitWorktrees({ openchamberBaseUrl, baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  return requestOpenChamberJson({ baseUrl: openchamberBaseUrl || baseUrl, endpoint: "/api/git/worktrees", directory: baseWorktree, fetchImpl });
+}
+async function verifyOpenChamberGitWorktree({ openchamberBaseUrl, baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const worktrees = await listOpenChamberGitWorktrees({ openchamberBaseUrl: openchamberBaseUrl || 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({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, worktreePath, branch, fetchImpl = globalThis.fetch } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  const effectiveOpenCodeBaseUrl = opencodeBaseUrl || baseUrl;
+  const gitWorktree = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  await requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, endpoint: "/experimental/workspace/sync-list", method: "POST", directory: baseWorktree, fetchImpl });
+  const project = await findOpenChamberProject({ opencodeBaseUrl: effectiveOpenCodeBaseUrl, baseWorktree, fetchImpl });
+  if (!project?.id) throw new Error("OpenCode project was not found after workspace sync; refusing to treat worktree as visible.");
+  await refreshOpenChamberProjectCopy({ opencodeBaseUrl: effectiveOpenCodeBaseUrl, projectId: project.id, fetchImpl });
+  const [worktrees, workspaces, directories] = await Promise.all([
+    listOpenChamberGitWorktrees({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, fetchImpl }),
+    requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, endpoint: "/experimental/workspace", directory: baseWorktree, fetchImpl }),
+    requestOpenCodeJson({ baseUrl: effectiveOpenCodeBaseUrl, 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(`OpenCode 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({ openchamberBaseUrl, baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists = false, fetchImpl = globalThis.fetch } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  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: effectiveOpenChamberBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, worktreePath: createdDirectory, branch, fetchImpl });
+  return { created, worktree: path5.resolve(createdDirectory), branch: createdBranch, verified };
+}
+async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
+  assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath });
+  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 } };
+}
+async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId, taskType = "Tarea", parentTaskId = "", subtaskId = "", existingMetadata = {}, runGitFn = runGit, openchamberBaseUrl = "", opencodeBaseUrl = "", baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
+  const effectiveOpenChamberBaseUrl = openchamberBaseUrl || baseUrl;
+  const effectiveOpenCodeBaseUrl = opencodeBaseUrl || baseUrl;
+  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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, branchExists: parentBranchExists, fetchImpl });
+      const parentVisibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists, fetchImpl });
+  const visibility = await syncOpenChamberWorktreeVisibility({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, opencodeBaseUrl: effectiveOpenCodeBaseUrl, 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 opencodeBaseUrlConfigured;
+  if (!openchamberBaseUrlConfigured || !openchamberBaseUrl) return ensureClickUpTaskWorktree(options);
+  try {
+    return await ensureClickUpTaskWorktreeOpenChamber({ ...options, openchamberBaseUrl, opencodeBaseUrl, 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") {
+      const taskId = options.taskId || "unknown task";
+      const ledgerPath = clickUpCommentLedgerPath(webhookWorktree);
+      const comment = `${message}
+
+Optima did not run raw git worktree fallback. Please verify clickup.openchamber.base_url and OpenCode/OpenChamber endpoint configuration.`;
+      let dedupe = { post: true, key: clickUpWorktreeFailureCommentKey({ taskId, message }) };
+      try {
+        dedupe = shouldPostClickUpWorktreeFailureComment({ ledgerPath, taskId, message });
+      } catch (ledgerError) {
+        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_comment_dedupe_failed", taskId, message: ledgerError.message });
+      }
+      if (dedupe.post) {
+        try {
+          await clickupClient.postTaskComment({ taskId: options.taskId, comment });
+          recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted: true });
+        } catch (commentError) {
+          appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_failed", taskId: options.taskId || null, message: commentError.message });
+        }
+      } else {
+        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_deduped", taskId, key: dedupe.key, reason: dedupe.reason });
+        recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted: false, skippedReason: dedupe.reason });
+      }
+    }
+    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 });
@@ -9592,6 +9826,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;
@@ -9603,7 +9842,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(
@@ -9611,6 +9851,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(),
@@ -9652,6 +9896,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");
@@ -10008,23 +10259,29 @@ function rememberClickUpWebhookEvent(state = {}, eventKey, limit = 200) {
   if (recent.includes(eventKey)) return { duplicate: true, state };
   return { duplicate: false, state: { ...state, recentEventKeys: [...recent, eventKey].slice(-limit) } };
 }
-function readClickUpCommentLedger(ledgerPath) {
-  const processed = /* @__PURE__ */ new Set();
-  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return processed;
+function readClickUpCommentLedgerEntries(ledgerPath) {
+  if (!ledgerPath || !fs5.existsSync(ledgerPath)) return [];
   try {
     const raw = fs5.readFileSync(ledgerPath, "utf8");
+    const entries = [];
     for (const [index, line] of raw.split(/\r?\n/).entries()) {
       if (!line.trim()) continue;
       try {
-        const entry = JSON.parse(line);
-        if (entry?.key) processed.add(String(entry.key));
+        entries.push(JSON.parse(line));
       } catch (error) {
         throw new Error(`malformed ledger row ${index + 1}: ${error.message}`);
       }
     }
+    return entries;
   } catch (error) {
     throw new Error(`ClickUp comment ledger unavailable: ${error.message}`);
   }
+}
+function readClickUpCommentLedger(ledgerPath) {
+  const processed = /* @__PURE__ */ new Set();
+  for (const entry of readClickUpCommentLedgerEntries(ledgerPath)) {
+    if (entry?.key) processed.add(String(entry.key));
+  }
   return processed;
 }
 function appendClickUpCommentLedgerEntry(ledgerPath, entry = {}) {
@@ -10090,6 +10347,35 @@ function recordClickUpCommentVersionProcessed({ ledgerPath, key, taskId, eventTy
     recordedAt: at.toISOString()
   });
 }
+function clickUpWorktreeFailureCommentKey({ taskId, message } = {}) {
+  const hash = crypto.createHash("sha256").update(String(message || "")).digest("hex").slice(0, 16);
+  return [String(taskId || "unknown").trim() || "unknown", "worktree_failure", hash].join(":");
+}
+function shouldPostClickUpWorktreeFailureComment({ ledgerPath, taskId, message, now = /* @__PURE__ */ new Date(), windowMs = CLICKUP_WORKTREE_FAILURE_COMMENT_DEDUPE_MS } = {}) {
+  const key = clickUpWorktreeFailureCommentKey({ taskId, message });
+  const nowMs = now instanceof Date ? now.getTime() : new Date(now).getTime();
+  for (const entry of readClickUpCommentLedgerEntries(ledgerPath).reverse()) {
+    if (entry?.key !== key) continue;
+    const postedAtMs = new Date(entry.postedAt || entry.recordedAt || entry.at || 0).getTime();
+    if (Number.isFinite(postedAtMs) && Number.isFinite(nowMs) && nowMs - postedAtMs <= windowMs) {
+      return { post: false, key, reason: "recent_duplicate" };
+    }
+    if (entry?.message === message) return { post: false, key, reason: "latest_equivalent" };
+  }
+  return { post: true, key };
+}
+function recordClickUpWorktreeFailureComment({ ledgerPath, taskId, message, posted = true, skippedReason = null, at = /* @__PURE__ */ new Date() } = {}) {
+  appendClickUpCommentLedgerEntry(ledgerPath, {
+    key: clickUpWorktreeFailureCommentKey({ taskId, message }),
+    taskId,
+    eventType: "worktree_failure",
+    action: posted ? "worktree_failure_comment_posted" : "worktree_failure_comment_skipped",
+    message,
+    posted,
+    skippedReason,
+    postedAt: at.toISOString()
+  });
+}
 function clickUpTaskIdFromPayload(payload = {}) {
   return String(payload.task_id || payload.taskId || payload.task?.id || payload.task?.task_id || "").trim();
 }
@@ -10941,7 +11227,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";
@@ -10997,7 +11283,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 });
@@ -13156,7 +13442,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, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defend-tech/opencode-optima",
-  "version": "0.1.59",
+  "version": "0.1.61",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/defend-tech/opencode-optima.git"