@defend-tech/opencode-optima 0.1.62 → 0.1.64

package/assets/agents/workflow_product_manager.md

@@ -33,7 +33,7 @@ You are Workflow_Product_Manager, Optima's ClickUp-first delivery orchestrator.
 
 - Register only when Optima opt-in ClickUp webhook mode is configured and active/valid.
 - Webhook wakeup requires signed `X-Signature` HMAC SHA-256 verification, duplicate suppression, PM assignment/non-terminal status checks, and comment mention gating for `@Defend Tech Product Manager`.
-- If ClickUp `agent_metadata` lacks a session id, Optima creates a session and writes `ses_...`; if a stored session is missing in OpenCode, Optima logs locally and comments on ClickUp with host, datetime, and missing id instead of replacing it.
+- Webhook routing is successful only after the worktree is OpenChamber-visible, an OpenCode `workflow_product_manager` session exists in that exact worktree directory, and prompt delivery/admission is verified. Worktree visibility alone is a launch failure, not successful routing.
 - Delivery task types: `Tarea`, `Bug`, `Doc`, `PoC`. Ignore unless converted/linked to delivery: `Idea`, legacy `Backlog`, `Hito`, `Nota de reunión`, `Respuesta del formulario`. Treat `Backlog` task type as `Idea`, not `backlog` status.
 - Branch-safe slugs: `Tarea` -> `tarea`, `Bug` -> `bug`, `Doc` -> `doc`, `PoC` -> `poc`. Unknown task type: pause and ask PMA/PO for clarification.
 

package/dist/index.js

@@ -8621,13 +8621,6 @@ var activeClickUpWebhookLifecycleRegistry = /* @__PURE__ */ new Map();
 var CLICKUP_WEBHOOK_CLEANUP_TIMEOUT_MS = 8e3;
 var CLICKUP_WEBHOOK_SIGNAL_STATE = Symbol.for("opencode-optima.clickup-webhook.signal-state");
 var activeClickUpTaskRoutes = /* @__PURE__ */ new Map();
-var objectIdentityMap = /* @__PURE__ */ new WeakMap();
-var objectIdentitySequence = 0;
-function objectIdentity(value) {
-  if (!value || typeof value !== "object" && typeof value !== "function") return String(value ?? "");
-  if (!objectIdentityMap.has(value)) objectIdentityMap.set(value, `obj_${++objectIdentitySequence}`);
-  return objectIdentityMap.get(value);
-}
 function isRootDirectory(candidate) {
   const resolved = path5.resolve(candidate);
   return resolved === path5.parse(resolved).root;
@@ -8753,7 +8746,6 @@ function hasActionableClickUpRoute(result = {}) {
   if (!result.sessionId) return false;
   if (result.action === "message_delivery_failed" || result.action === "error") return false;
   if (result.deliveryVerification?.ok === false) return false;
-  if (result.deliveryVerification?.method === "prompt_admission") return false;
   return true;
 }
 function determineClickUpMergeAuthority({ isSubtask = false, clickupStatus = "", validationPassed = false, mergeFailed = false, finalApprovalRoles = CLICKUP_FINAL_APPROVER_ROLES, humansRegistry } = {}) {
@@ -9350,11 +9342,6 @@ async function syncOpenChamberWorktreeVisibility({ openchamberBaseUrl, opencodeB
   }
   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);
@@ -9377,7 +9364,6 @@ async function createOpenChamberClickUpWorktree({ openchamberBaseUrl, baseUrl, b
   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 } };
 }
@@ -9431,30 +9417,6 @@ async function ensureClickUpTaskWorktreeForWebhook({ opencodeBaseUrl = "", openc
   } 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);
   }
 }
@@ -10400,35 +10362,6 @@ 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();
 }
@@ -10562,12 +10495,16 @@ function clearClickUpPendingSessionMetadata(metadata, metadataKey) {
   delete cursor[parts[parts.length - 1]];
   return JSON.stringify(sortJsonValue(root), null, 2);
 }
-async function openCodeSessionExists(client, sessionId) {
+function withOptionalDirectoryQuery(payload, directory) {
+  if (!directory) return payload;
+  return { ...payload, query: { ...payload.query || {}, directory } };
+}
+async function openCodeSessionExists(client, sessionId, { directory = "" } = {}) {
   const getAttempts = [
-    { path: { id: sessionId } },
-    { path: { sessionID: sessionId } },
-    { sessionID: sessionId },
-    { id: sessionId }
+    withOptionalDirectoryQuery({ path: { id: sessionId } }, directory),
+    withOptionalDirectoryQuery({ path: { sessionID: sessionId } }, directory),
+    directory ? { sessionID: sessionId, directory } : { sessionID: sessionId },
+    directory ? { id: sessionId, directory } : { id: sessionId }
   ];
   if (typeof client?.session?.get === "function") {
     for (const attempt of getAttempts) {
@@ -10579,10 +10516,10 @@ async function openCodeSessionExists(client, sessionId) {
     }
   }
   const messageAttempts = [
-    { path: { id: sessionId }, query: { limit: 1 } },
-    { path: { sessionID: sessionId }, query: { limit: 1 } },
-    { sessionID: sessionId, limit: 1 },
-    { id: sessionId, limit: 1 }
+    { path: { id: sessionId }, query: { limit: 1, ...directory ? { directory } : {} } },
+    { path: { sessionID: sessionId }, query: { limit: 1, ...directory ? { directory } : {} } },
+    directory ? { sessionID: sessionId, directory, limit: 1 } : { sessionID: sessionId, limit: 1 },
+    directory ? { id: sessionId, directory, limit: 1 } : { id: sessionId, limit: 1 }
   ];
   if (typeof client?.session?.messages === "function") {
     for (const attempt of messageAttempts) {
@@ -10986,6 +10923,11 @@ async function verifyOpenCodeSessionEventDelivery(client, { sessionId, directory
   }
   return { ok: false, reason: lastError };
 }
+async function postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason, source } = {}) {
+  void clickupClient;
+  appendClickUpWebhookLocalLog(worktree, { type: "launch_failure_comment_skipped", taskId, reason, source, policy: "local_log_only" });
+  return { ok: false, skipped: true, reason: "local_log_only" };
+}
 async function applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
   if (typeof clickupClient?.addTaskTag !== "function") {
     appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_unavailable", taskId, reason, source, tagName });
@@ -11015,7 +10957,17 @@ function openCodeBlockingPromptVerification(result, sessionId) {
 }
 async function deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent, text, directory, opencodeBaseUrl, directPrompt = false, acceptPromptAdmission = false, eventMarkers = [], verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, applyBlockerOnFailure = true } = {}) {
   const beforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, directory, limit: 50 }).catch(() => null);
-  const sendResult = await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: directPrompt, allowDirectFallback: directPrompt });
+  let sendResult;
+  try {
+    sendResult = await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: directPrompt, allowDirectFallback: directPrompt });
+  } catch (error) {
+    const reason2 = error.message || "message_delivery_failed";
+    appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason: reason2, fallbackAttempted: false });
+    if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason: reason2, taskId, sessionId, fallbackAttempted: false };
+    const blocker2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: reason2, source: "delivery_send_failed" });
+    const launchFailureComment2 = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: reason2, source: "delivery_send_failed" });
+    return { ok: false, action: "message_delivery_failed", reason: reason2, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2, launchFailureComment: launchFailureComment2 };
+  }
   let blockingPromptVerification = null;
   let admissionVerification = null;
   try {
@@ -11025,7 +10977,8 @@ async function deliverClickUpSessionEventWithVerification({ openCodeClient, send
     appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason: error.message, fallbackAttempted: false });
     if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false };
     const blocker2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: error.message, source: "delivery_admission_failed" });
-    return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2 };
+    const launchFailureComment2 = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: error.message, source: "delivery_admission_failed" });
+    return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2, launchFailureComment: launchFailureComment2 };
   }
   if (blockingPromptVerification) return { ok: true, verification: blockingPromptVerification, admissionVerification: null, fallback: false };
   if (admissionVerification && acceptPromptAdmission) {
@@ -11040,7 +10993,8 @@ async function deliverClickUpSessionEventWithVerification({ openCodeClient, send
   appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason, fallbackAttempted: false, httpFallbackDisabled: Boolean(opencodeBaseUrl) });
   if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false };
   const blocker = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source: "delivery_verification_failed" });
-  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker };
+  const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason, source: "delivery_verification_failed" });
+  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker, launchFailureComment };
 }
 async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, staleSessionId, sessionTitle, taskRoute, metadataWithRouting, config, prompt, eventMarkers = [], deliveryEvidencePath, evidencePath, eventKey, createSession, verifySessionEventDelivery } = {}) {
   appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_started", taskId, staleSessionId, worktree: taskRoute?.worktree });
@@ -11050,12 +11004,14 @@ async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, click
   } catch (error) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_create_failed", taskId, staleSessionId, message: error.message });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
-    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
+    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   if (!String(replacementSessionId || "").startsWith("ses_")) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_create_invalid", taskId, staleSessionId, replacementSessionId });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
-    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
+    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   const replacementDelivery = await deliverClickUpSessionEventWithVerification({
     openCodeClient,
@@ -11077,7 +11033,8 @@ async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, click
   if (!replacementDelivery.ok) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_delivery_failed", taskId, staleSessionId, replacementSessionId, reason: replacementDelivery.reason });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: replacementDelivery.reason || "replacement_delivery_failed", source: "pm_session_recovery" });
-    return { ...replacementDelivery, sessionId: staleSessionId, replacementSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = replacementDelivery.launchFailureComment || await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: replacementDelivery.reason || "replacement_delivery_failed", source: "pm_session_recovery" });
+    return { ...replacementDelivery, sessionId: staleSessionId, replacementSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   const replacementMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(metadataWithRouting, config.routing.metadataKey, replacementSessionId), config.routing.metadataKey);
   await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: replacementMetadata });
@@ -11361,8 +11318,26 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   if (!existingSessionId) {
     let pendingSessionId = getNestedMetadataValue(metadata, clickUpPendingSessionKey(config.routing.metadataKey)) || state.pendingSessions?.[taskId];
     if (!pendingSessionId) {
-      pendingSessionId = await createSession(openCodeClient, { title: sessionTitle, directory: taskRoute.worktree, agent: config.routing.targetAgent });
-      if (!String(pendingSessionId || "").startsWith("ses_")) return { ok: false, action: "error", reason: "session_create_failed", taskId };
+      try {
+        pendingSessionId = await createSession(openCodeClient, { title: sessionTitle, directory: taskRoute.worktree, agent: config.routing.targetAgent });
+      } catch (error) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_failed", taskId, worktree: taskRoute.worktree, message: error.message });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_create_failed", taskId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
+      if (!String(pendingSessionId || "").startsWith("ses_")) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_invalid", taskId, worktree: taskRoute.worktree, sessionId: pendingSessionId || null });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_create_failed", taskId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
+      if (!await sessionExists(openCodeClient, pendingSessionId, { directory: taskRoute.worktree })) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_directory_unverified", taskId, worktree: taskRoute.worktree, sessionId: pendingSessionId });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_directory_unverified", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_directory_unverified", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_directory_unverified", taskId, sessionId: pendingSessionId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
       if (saveState) {
         saveState({
           ...state,
@@ -11378,7 +11353,20 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
       throw error;
     }
     const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, directPrompt: config.opencode?.promptDelivery === "http", acceptPromptAdmission: config.opencode?.acceptPromptAdmission === true, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
-    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    if (!delivery.ok) {
+      const failedMetadata = clearClickUpPendingSessionMetadata(metadataWithRouting, config.routing.metadataKey);
+      let pendingCleared = false;
+      try {
+        await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: failedMetadata });
+        pendingCleared = true;
+      } catch (error) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pending_session_clear_failed", taskId, sessionId: pendingSessionId, message: error.message });
+      }
+      const { [taskId]: _failedPending, ...remainingPending2 } = stateToPersist.pendingSessions || {};
+      stateToPersist = { ...stateToPersist, pendingSessions: remainingPending2 };
+      appendClickUpWebhookLocalLog(worktree, { type: "pending_session_delivery_failed", taskId, sessionId: pendingSessionId, reason: delivery.reason || "message_delivery_failed", pendingCleared });
+      return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, pendingCleared });
+    }
     const nextMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(pendingMetadata, config.routing.metadataKey, pendingSessionId), config.routing.metadataKey);
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
@@ -11386,7 +11374,7 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
     return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryAdmission: delivery.admissionVerification, deliveryFallback: delivery.fallback, deliveryAttempts: delivery.fallback ? 2 : 1 });
   }
   const sessionId = String(existingSessionId);
-  if (await sessionExists(openCodeClient, sessionId)) {
+  if (await sessionExists(openCodeClient, sessionId, { directory: taskRoute.worktree })) {
     if (typeof clickupClient?.updateTaskMetadata === "function") await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: metadataWithRouting });
     const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, directPrompt: config.opencode?.promptDelivery === "http", acceptPromptAdmission: config.opencode?.acceptPromptAdmission === true, eventMarkers: [taskId, eventType], verifySessionEventDelivery, applyBlockerOnFailure: false });
     if (!delivery.ok) {
@@ -11514,6 +11502,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
         routed.undelivered += 1;
         appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: result?.action || "error", sessionId: routeSummary.sessionId, reason: result.reason || "startup_reconciliation_route_failed" });
         if (!result.blockerTag) await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
+        if (!result.launchFailureComment) await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
       } else {
         routed.undelivered += 1;
         appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: routeSummary.action, sessionId: routeSummary.sessionId, reason: "route_not_actionable" });
@@ -11621,14 +11610,13 @@ function clickUpListenerKey(config) {
 }
 function clickUpListenerFingerprint({ config, state, worktree, clickupClient, openCodeClient } = {}) {
   return JSON.stringify({
+    teamId: config?.teamId || "",
     publicUrl: config?.webhook?.publicUrl || "",
     path: clickUpWebhookExpectedPath(config),
-    worktree: path5.resolve(worktree || process.cwd()),
+    location: config?.webhook?.location || {},
     webhookId: state?.webhookId || "",
     secret: state?.secret || "",
-    events: config?.webhook?.events || [],
-    clickupClient: objectIdentity(clickupClient),
-    openCodeClient: objectIdentity(openCodeClient)
+    events: config?.webhook?.events || []
   });
 }
 function startClickUpWebhookListener({ config, state, worktree, clickupClient, openCodeClient, listenerRegistry = activeClickUpWebhookListeners } = {}) {

package/dist/sanitize_cli.js

@@ -8628,13 +8628,6 @@ var activeClickUpWebhookLifecycleRegistry = /* @__PURE__ */ new Map();
 var CLICKUP_WEBHOOK_CLEANUP_TIMEOUT_MS = 8e3;
 var CLICKUP_WEBHOOK_SIGNAL_STATE = Symbol.for("opencode-optima.clickup-webhook.signal-state");
 var activeClickUpTaskRoutes = /* @__PURE__ */ new Map();
-var objectIdentityMap = /* @__PURE__ */ new WeakMap();
-var objectIdentitySequence = 0;
-function objectIdentity(value) {
-  if (!value || typeof value !== "object" && typeof value !== "function") return String(value ?? "");
-  if (!objectIdentityMap.has(value)) objectIdentityMap.set(value, `obj_${++objectIdentitySequence}`);
-  return objectIdentityMap.get(value);
-}
 function isRootDirectory(candidate) {
   const resolved = path5.resolve(candidate);
   return resolved === path5.parse(resolved).root;
@@ -8760,7 +8753,6 @@ function hasActionableClickUpRoute(result = {}) {
   if (!result.sessionId) return false;
   if (result.action === "message_delivery_failed" || result.action === "error") return false;
   if (result.deliveryVerification?.ok === false) return false;
-  if (result.deliveryVerification?.method === "prompt_admission") return false;
   return true;
 }
 function determineClickUpMergeAuthority({ isSubtask = false, clickupStatus = "", validationPassed = false, mergeFailed = false, finalApprovalRoles = CLICKUP_FINAL_APPROVER_ROLES, humansRegistry } = {}) {
@@ -9357,11 +9349,6 @@ async function syncOpenChamberWorktreeVisibility({ openchamberBaseUrl, opencodeB
   }
   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);
@@ -9384,7 +9371,6 @@ async function createOpenChamberClickUpWorktree({ openchamberBaseUrl, baseUrl, b
   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 } };
 }
@@ -9438,30 +9424,6 @@ async function ensureClickUpTaskWorktreeForWebhook({ opencodeBaseUrl = "", openc
   } 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);
   }
 }
@@ -10407,35 +10369,6 @@ 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();
 }
@@ -10569,12 +10502,16 @@ function clearClickUpPendingSessionMetadata(metadata, metadataKey) {
   delete cursor[parts[parts.length - 1]];
   return JSON.stringify(sortJsonValue(root), null, 2);
 }
-async function openCodeSessionExists(client, sessionId) {
+function withOptionalDirectoryQuery(payload, directory) {
+  if (!directory) return payload;
+  return { ...payload, query: { ...payload.query || {}, directory } };
+}
+async function openCodeSessionExists(client, sessionId, { directory = "" } = {}) {
   const getAttempts = [
-    { path: { id: sessionId } },
-    { path: { sessionID: sessionId } },
-    { sessionID: sessionId },
-    { id: sessionId }
+    withOptionalDirectoryQuery({ path: { id: sessionId } }, directory),
+    withOptionalDirectoryQuery({ path: { sessionID: sessionId } }, directory),
+    directory ? { sessionID: sessionId, directory } : { sessionID: sessionId },
+    directory ? { id: sessionId, directory } : { id: sessionId }
   ];
   if (typeof client?.session?.get === "function") {
     for (const attempt of getAttempts) {
@@ -10586,10 +10523,10 @@ async function openCodeSessionExists(client, sessionId) {
     }
   }
   const messageAttempts = [
-    { path: { id: sessionId }, query: { limit: 1 } },
-    { path: { sessionID: sessionId }, query: { limit: 1 } },
-    { sessionID: sessionId, limit: 1 },
-    { id: sessionId, limit: 1 }
+    { path: { id: sessionId }, query: { limit: 1, ...directory ? { directory } : {} } },
+    { path: { sessionID: sessionId }, query: { limit: 1, ...directory ? { directory } : {} } },
+    directory ? { sessionID: sessionId, directory, limit: 1 } : { sessionID: sessionId, limit: 1 },
+    directory ? { id: sessionId, directory, limit: 1 } : { id: sessionId, limit: 1 }
   ];
   if (typeof client?.session?.messages === "function") {
     for (const attempt of messageAttempts) {
@@ -10993,6 +10930,11 @@ async function verifyOpenCodeSessionEventDelivery(client, { sessionId, directory
   }
   return { ok: false, reason: lastError };
 }
+async function postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason, source } = {}) {
+  void clickupClient;
+  appendClickUpWebhookLocalLog(worktree, { type: "launch_failure_comment_skipped", taskId, reason, source, policy: "local_log_only" });
+  return { ok: false, skipped: true, reason: "local_log_only" };
+}
 async function applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
   if (typeof clickupClient?.addTaskTag !== "function") {
     appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_unavailable", taskId, reason, source, tagName });
@@ -11022,7 +10964,17 @@ function openCodeBlockingPromptVerification(result, sessionId) {
 }
 async function deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent, text, directory, opencodeBaseUrl, directPrompt = false, acceptPromptAdmission = false, eventMarkers = [], verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, applyBlockerOnFailure = true } = {}) {
   const beforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, directory, limit: 50 }).catch(() => null);
-  const sendResult = await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: directPrompt, allowDirectFallback: directPrompt });
+  let sendResult;
+  try {
+    sendResult = await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: directPrompt, allowDirectFallback: directPrompt });
+  } catch (error) {
+    const reason2 = error.message || "message_delivery_failed";
+    appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason: reason2, fallbackAttempted: false });
+    if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason: reason2, taskId, sessionId, fallbackAttempted: false };
+    const blocker2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: reason2, source: "delivery_send_failed" });
+    const launchFailureComment2 = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: reason2, source: "delivery_send_failed" });
+    return { ok: false, action: "message_delivery_failed", reason: reason2, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2, launchFailureComment: launchFailureComment2 };
+  }
   let blockingPromptVerification = null;
   let admissionVerification = null;
   try {
@@ -11032,7 +10984,8 @@ async function deliverClickUpSessionEventWithVerification({ openCodeClient, send
     appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason: error.message, fallbackAttempted: false });
     if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false };
     const blocker2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: error.message, source: "delivery_admission_failed" });
-    return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2 };
+    const launchFailureComment2 = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: error.message, source: "delivery_admission_failed" });
+    return { ok: false, action: "message_delivery_failed", reason: error.message, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker2, launchFailureComment: launchFailureComment2 };
   }
   if (blockingPromptVerification) return { ok: true, verification: blockingPromptVerification, admissionVerification: null, fallback: false };
   if (admissionVerification && acceptPromptAdmission) {
@@ -11047,7 +11000,8 @@ async function deliverClickUpSessionEventWithVerification({ openCodeClient, send
   appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason, fallbackAttempted: false, httpFallbackDisabled: Boolean(opencodeBaseUrl) });
   if (!applyBlockerOnFailure) return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false };
   const blocker = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source: "delivery_verification_failed" });
-  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker };
+  const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason, source: "delivery_verification_failed" });
+  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: false, blockerTag: blocker, launchFailureComment };
 }
 async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, staleSessionId, sessionTitle, taskRoute, metadataWithRouting, config, prompt, eventMarkers = [], deliveryEvidencePath, evidencePath, eventKey, createSession, verifySessionEventDelivery } = {}) {
   appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_started", taskId, staleSessionId, worktree: taskRoute?.worktree });
@@ -11057,12 +11011,14 @@ async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, click
   } catch (error) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_create_failed", taskId, staleSessionId, message: error.message });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
-    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
+    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   if (!String(replacementSessionId || "").startsWith("ses_")) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_create_invalid", taskId, staleSessionId, replacementSessionId });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
-    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "replacement_session_create_failed", source: "pm_session_recovery" });
+    return { ok: false, action: "message_delivery_failed", reason: "replacement_session_create_failed", taskId, sessionId: staleSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   const replacementDelivery = await deliverClickUpSessionEventWithVerification({
     openCodeClient,
@@ -11084,7 +11040,8 @@ async function recoverClickUpPmSession({ openCodeClient, sendSessionEvent, click
   if (!replacementDelivery.ok) {
     appendClickUpWebhookLocalLog(worktree, { type: "pm_session_recovery_delivery_failed", taskId, staleSessionId, replacementSessionId, reason: replacementDelivery.reason });
     const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: replacementDelivery.reason || "replacement_delivery_failed", source: "pm_session_recovery" });
-    return { ...replacementDelivery, sessionId: staleSessionId, replacementSessionId, replacementAttempted: true, blockerTag, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
+    const launchFailureComment = replacementDelivery.launchFailureComment || await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: replacementDelivery.reason || "replacement_delivery_failed", source: "pm_session_recovery" });
+    return { ...replacementDelivery, sessionId: staleSessionId, replacementSessionId, replacementAttempted: true, blockerTag, launchFailureComment, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath };
   }
   const replacementMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(metadataWithRouting, config.routing.metadataKey, replacementSessionId), config.routing.metadataKey);
   await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: replacementMetadata });
@@ -11368,8 +11325,26 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   if (!existingSessionId) {
     let pendingSessionId = getNestedMetadataValue(metadata, clickUpPendingSessionKey(config.routing.metadataKey)) || state.pendingSessions?.[taskId];
     if (!pendingSessionId) {
-      pendingSessionId = await createSession(openCodeClient, { title: sessionTitle, directory: taskRoute.worktree, agent: config.routing.targetAgent });
-      if (!String(pendingSessionId || "").startsWith("ses_")) return { ok: false, action: "error", reason: "session_create_failed", taskId };
+      try {
+        pendingSessionId = await createSession(openCodeClient, { title: sessionTitle, directory: taskRoute.worktree, agent: config.routing.targetAgent });
+      } catch (error) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_failed", taskId, worktree: taskRoute.worktree, message: error.message });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_create_failed", taskId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
+      if (!String(pendingSessionId || "").startsWith("ses_")) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_invalid", taskId, worktree: taskRoute.worktree, sessionId: pendingSessionId || null });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_create_failed", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_create_failed", taskId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
+      if (!await sessionExists(openCodeClient, pendingSessionId, { directory: taskRoute.worktree })) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pm_session_create_directory_unverified", taskId, worktree: taskRoute.worktree, sessionId: pendingSessionId });
+        const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "session_directory_unverified", source: "route_create_session" });
+        const launchFailureComment = await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: "session_directory_unverified", source: "route_create_session" });
+        return finish({ ok: false, action: "error", reason: "session_directory_unverified", taskId, sessionId: pendingSessionId, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag, launchFailureComment });
+      }
       if (saveState) {
         saveState({
           ...state,
@@ -11385,7 +11360,20 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
       throw error;
     }
     const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, directPrompt: config.opencode?.promptDelivery === "http", acceptPromptAdmission: config.opencode?.acceptPromptAdmission === true, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
-    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    if (!delivery.ok) {
+      const failedMetadata = clearClickUpPendingSessionMetadata(metadataWithRouting, config.routing.metadataKey);
+      let pendingCleared = false;
+      try {
+        await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: failedMetadata });
+        pendingCleared = true;
+      } catch (error) {
+        appendClickUpWebhookLocalLog(worktree, { type: "pending_session_clear_failed", taskId, sessionId: pendingSessionId, message: error.message });
+      }
+      const { [taskId]: _failedPending, ...remainingPending2 } = stateToPersist.pendingSessions || {};
+      stateToPersist = { ...stateToPersist, pendingSessions: remainingPending2 };
+      appendClickUpWebhookLocalLog(worktree, { type: "pending_session_delivery_failed", taskId, sessionId: pendingSessionId, reason: delivery.reason || "message_delivery_failed", pendingCleared });
+      return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, pendingCleared });
+    }
     const nextMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(pendingMetadata, config.routing.metadataKey, pendingSessionId), config.routing.metadataKey);
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
@@ -11393,7 +11381,7 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
     return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryAdmission: delivery.admissionVerification, deliveryFallback: delivery.fallback, deliveryAttempts: delivery.fallback ? 2 : 1 });
   }
   const sessionId = String(existingSessionId);
-  if (await sessionExists(openCodeClient, sessionId)) {
+  if (await sessionExists(openCodeClient, sessionId, { directory: taskRoute.worktree })) {
     if (typeof clickupClient?.updateTaskMetadata === "function") await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: metadataWithRouting });
     const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, directPrompt: config.opencode?.promptDelivery === "http", acceptPromptAdmission: config.opencode?.acceptPromptAdmission === true, eventMarkers: [taskId, eventType], verifySessionEventDelivery, applyBlockerOnFailure: false });
     if (!delivery.ok) {
@@ -11521,6 +11509,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
         routed.undelivered += 1;
         appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: result?.action || "error", sessionId: routeSummary.sessionId, reason: result.reason || "startup_reconciliation_route_failed" });
         if (!result.blockerTag) await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
+        if (!result.launchFailureComment) await postClickUpLaunchFailureComment({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
       } else {
         routed.undelivered += 1;
         appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: routeSummary.action, sessionId: routeSummary.sessionId, reason: "route_not_actionable" });
@@ -11628,14 +11617,13 @@ function clickUpListenerKey(config) {
 }
 function clickUpListenerFingerprint({ config, state, worktree, clickupClient, openCodeClient } = {}) {
   return JSON.stringify({
+    teamId: config?.teamId || "",
     publicUrl: config?.webhook?.publicUrl || "",
     path: clickUpWebhookExpectedPath(config),
-    worktree: path5.resolve(worktree || process.cwd()),
+    location: config?.webhook?.location || {},
     webhookId: state?.webhookId || "",
     secret: state?.secret || "",
-    events: config?.webhook?.events || [],
-    clickupClient: objectIdentity(clickupClient),
-    openCodeClient: objectIdentity(openCodeClient)
+    events: config?.webhook?.events || []
   });
 }
 function startClickUpWebhookListener({ config, state, worktree, clickupClient, openCodeClient, listenerRegistry = activeClickUpWebhookListeners } = {}) {

package/package.json

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