@defend-tech/opencode-optima 0.1.60 → 0.1.61

package/assets/agents/workflow_product_manager.md

@@ -52,7 +52,7 @@ 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`; 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.opencode.base_url` for legacy OpenCode session/prompt delivery, not as the preferred worktree creation API when `clickup.openchamber.base_url` is configured.
+- 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.

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;
@@ -9234,30 +9235,36 @@ function openChamberUrl(baseUrl, pathname, query = {}) {
   }
   return url.toString();
 }
-async function readOpenChamberJson(response, endpoint) {
+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(`OpenChamber ${endpoint} returned non-JSON response.`);
+      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(`OpenChamber ${endpoint} failed: ${response.status} ${message}`);
+    throw new Error(`${serviceName} ${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.");
+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);
+  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;
@@ -9296,39 +9303,40 @@ function openChamberListIncludesBranch(list, directory, branch) {
     return !entryBranch || entryBranch === branch;
   });
 }
-async function findOpenChamberProject({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
-  const projects = await requestOpenChamberJson({ baseUrl, endpoint: "/project", directory: baseWorktree, fetchImpl });
+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({ baseUrl, baseWorktree, projectId, fetchImpl = globalThis.fetch } = {}) {
+async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, 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");
+  await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: `/experimental/project/${encodeURIComponent(projectId)}/copy/refresh`, method: "POST", fetchImpl });
   return { refreshed: true, projectId };
 }
-async function listOpenChamberGitWorktrees({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
-  return requestOpenChamberJson({ baseUrl, endpoint: "/api/git/worktrees", directory: baseWorktree, fetchImpl });
+async function listOpenChamberGitWorktrees({ openchamberBaseUrl, baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  return requestOpenChamberJson({ baseUrl: openchamberBaseUrl || 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 });
+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({ 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 });
+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({ baseUrl, baseWorktree, fetchImpl }),
-    requestOpenChamberJson({ baseUrl, endpoint: "/experimental/workspace", directory: baseWorktree, fetchImpl }),
-    requestOpenChamberJson({ baseUrl, endpoint: `/project/${encodeURIComponent(project.id)}/directories`, directory: baseWorktree, fetchImpl })
+    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),
@@ -9338,7 +9346,7 @@ async function syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktr
     projectId: project.id
   };
   if (!visibility.worktree || !visibility.workspace || !visibility.projectDirectory) {
-    throw new Error(`OpenChamber visibility verification failed for ${worktreePath}: ${JSON.stringify(visibility)}`);
+    throw new Error(`OpenCode visibility verification failed for ${worktreePath}: ${JSON.stringify(visibility)}`);
   }
   return visibility;
 }
@@ -9347,12 +9355,13 @@ function assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath } = {
     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 } = {}) {
+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, endpoint: "/api/git/worktrees", method: "POST", directory: baseWorktree, body, fetchImpl });
+    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}`);
   }
@@ -9364,15 +9373,17 @@ async function createOpenChamberClickUpWorktree({ baseUrl, baseWorktree, 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 });
+  const verified = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, 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" } = {}) {
+async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
   assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath });
-  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  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, baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
+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 }) : "";
@@ -9380,13 +9391,13 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", 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" });
+    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({ baseUrl, baseWorktree, branch, worktreePath, fetchImpl, source: "existing_directory" });
+    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 };
   }
@@ -9394,40 +9405,54 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId,
   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" });
+      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({ baseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, branchExists: parentBranchExists, fetchImpl });
-      const parentVisibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: createdParent.worktree, branch: parentBranch, fetchImpl });
+      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({ baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists, fetchImpl });
-  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: created.worktree, branch, fetchImpl });
+  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 opencodeBaseUrl;
   void opencodeBaseUrlConfigured;
   if (!openchamberBaseUrlConfigured || !openchamberBaseUrl) return ensureClickUpTaskWorktree(options);
   try {
-    return await ensureClickUpTaskWorktreeOpenChamber({ ...options, baseUrl: openchamberBaseUrl, fetchImpl, log: (entry) => appendClickUpWebhookLocalLog(webhookWorktree, entry) });
+    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") {
-      try {
-        await clickupClient.postTaskComment({ taskId: options.taskId, comment: `${message}
+      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 OpenChamber Git API compatibility.` });
-      } catch (commentError) {
-        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_failed", taskId: options.taskId || null, message: commentError.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);
@@ -10227,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 = {}) {
@@ -10309,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();
 }

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;
@@ -9241,30 +9242,36 @@ function openChamberUrl(baseUrl, pathname, query = {}) {
   }
   return url.toString();
 }
-async function readOpenChamberJson(response, endpoint) {
+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(`OpenChamber ${endpoint} returned non-JSON response.`);
+      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(`OpenChamber ${endpoint} failed: ${response.status} ${message}`);
+    throw new Error(`${serviceName} ${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.");
+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);
+  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;
@@ -9303,39 +9310,40 @@ function openChamberListIncludesBranch(list, directory, branch) {
     return !entryBranch || entryBranch === branch;
   });
 }
-async function findOpenChamberProject({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
-  const projects = await requestOpenChamberJson({ baseUrl, endpoint: "/project", directory: baseWorktree, fetchImpl });
+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({ baseUrl, baseWorktree, projectId, fetchImpl = globalThis.fetch } = {}) {
+async function refreshOpenChamberProjectCopy({ opencodeBaseUrl, 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");
+  await requestOpenCodeJson({ baseUrl: opencodeBaseUrl, endpoint: `/experimental/project/${encodeURIComponent(projectId)}/copy/refresh`, method: "POST", fetchImpl });
   return { refreshed: true, projectId };
 }
-async function listOpenChamberGitWorktrees({ baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
-  return requestOpenChamberJson({ baseUrl, endpoint: "/api/git/worktrees", directory: baseWorktree, fetchImpl });
+async function listOpenChamberGitWorktrees({ openchamberBaseUrl, baseUrl, baseWorktree, fetchImpl = globalThis.fetch } = {}) {
+  return requestOpenChamberJson({ baseUrl: openchamberBaseUrl || 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 });
+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({ 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 });
+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({ baseUrl, baseWorktree, fetchImpl }),
-    requestOpenChamberJson({ baseUrl, endpoint: "/experimental/workspace", directory: baseWorktree, fetchImpl }),
-    requestOpenChamberJson({ baseUrl, endpoint: `/project/${encodeURIComponent(project.id)}/directories`, directory: baseWorktree, fetchImpl })
+    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),
@@ -9345,7 +9353,7 @@ async function syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktr
     projectId: project.id
   };
   if (!visibility.worktree || !visibility.workspace || !visibility.projectDirectory) {
-    throw new Error(`OpenChamber visibility verification failed for ${worktreePath}: ${JSON.stringify(visibility)}`);
+    throw new Error(`OpenCode visibility verification failed for ${worktreePath}: ${JSON.stringify(visibility)}`);
   }
   return visibility;
 }
@@ -9354,12 +9362,13 @@ function assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath } = {
     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 } = {}) {
+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, endpoint: "/api/git/worktrees", method: "POST", directory: baseWorktree, body, fetchImpl });
+    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}`);
   }
@@ -9371,15 +9380,17 @@ async function createOpenChamberClickUpWorktree({ baseUrl, baseWorktree, 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 });
+  const verified = await verifyOpenChamberGitWorktree({ openchamberBaseUrl: effectiveOpenChamberBaseUrl, 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" } = {}) {
+async function registerOpenChamberClickUpWorktree({ openchamberBaseUrl, opencodeBaseUrl, baseUrl, baseWorktree, branch, worktreePath, fetchImpl = globalThis.fetch, source = "reuse" } = {}) {
   assertOpenChamberClickUpWorktreePath({ baseWorktree, worktreePath });
-  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath, branch, fetchImpl });
+  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, baseUrl = "", fetchImpl = globalThis.fetch, log = null } = {}) {
+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 }) : "";
@@ -9387,13 +9398,13 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", 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" });
+    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({ baseUrl, baseWorktree, branch, worktreePath, fetchImpl, source: "existing_directory" });
+    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 };
   }
@@ -9401,40 +9412,54 @@ async function ensureClickUpTaskWorktreeOpenChamber({ baseWorktree = "", taskId,
   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" });
+      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({ baseUrl, baseWorktree, branch: parentBranch, worktreePath: parentWorktree, startPoint: parentStartPoint, branchExists: parentBranchExists, fetchImpl });
-      const parentVisibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: createdParent.worktree, branch: parentBranch, fetchImpl });
+      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({ baseUrl, baseWorktree, branch, worktreePath, startPoint, branchExists, fetchImpl });
-  const visibility = await syncOpenChamberWorktreeVisibility({ baseUrl, baseWorktree, worktreePath: created.worktree, branch, fetchImpl });
+  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 opencodeBaseUrl;
   void opencodeBaseUrlConfigured;
   if (!openchamberBaseUrlConfigured || !openchamberBaseUrl) return ensureClickUpTaskWorktree(options);
   try {
-    return await ensureClickUpTaskWorktreeOpenChamber({ ...options, baseUrl: openchamberBaseUrl, fetchImpl, log: (entry) => appendClickUpWebhookLocalLog(webhookWorktree, entry) });
+    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") {
-      try {
-        await clickupClient.postTaskComment({ taskId: options.taskId, comment: `${message}
+      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 OpenChamber Git API compatibility.` });
-      } catch (commentError) {
-        appendClickUpWebhookLocalLog(webhookWorktree, { type: "openchamber_worktree_blocker_comment_failed", taskId: options.taskId || null, message: commentError.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);
@@ -10234,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 = {}) {
@@ -10316,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();
 }

package/package.json

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