@defend-tech/opencode-optima 0.1.65 → 0.1.67

package/dist/index.js

@@ -9978,17 +9978,11 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         body: JSON.stringify({ value })
       });
     },
-    async postTaskComment({ taskId, comment }) {
-      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/comment`, {
-        method: "POST",
-        body: JSON.stringify({ comment_text: comment })
-      });
+    async postTaskComment() {
+      throw new Error("Optima runtime does not post ClickUp task comments; use local logs for process failures.");
     },
-    async addTaskTag({ taskId, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
-      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/tag/${encodeURIComponent(tagName)}`, {
-        method: "POST",
-        body: JSON.stringify({})
-      });
+    async addTaskTag() {
+      throw new Error("Optima runtime does not add ClickUp task tags; use local logs for process failures.");
     },
     async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
       const params = new URLSearchParams();
@@ -10548,15 +10542,54 @@ async function createOpenCodeSession(client, { title, directory, agent } = {}) {
     throw error || new Error("OpenCode session create failed.");
   }
 }
-async function waitForOpenCodeReadiness(client, { worktree = process.cwd(), attempts = 10, delayMs = 500, now = () => /* @__PURE__ */ new Date() } = {}) {
-  if (typeof client?.session?.create !== "function") return { ok: true, skipped: true, reason: "session_create_probe_unavailable" };
+function normalizeOpenCodeSessionCollection(value) {
+  if (Array.isArray(value)) return value;
+  if (!isPlainObject(value)) return [];
+  for (const key of ["sessions", "items", "data", "result", "results"]) {
+    const nested = value[key];
+    if (Array.isArray(nested)) return nested;
+    if (isPlainObject(nested)) {
+      const normalized = normalizeOpenCodeSessionCollection(nested);
+      if (normalized.length > 0) return normalized;
+    }
+  }
+  return [];
+}
+async function listOpenCodeSessionsReadiness(client, { directory = "" } = {}) {
+  if (typeof client?.session?.list !== "function") return null;
+  const attempts = [
+    { query: directory ? { directory } : {} },
+    directory ? { directory } : {}
+  ];
+  for (const attempt of attempts) {
+    try {
+      const result = await client.session.list(attempt);
+      return { ok: true, method: "session_list", sessions: normalizeOpenCodeSessionCollection(result?.data ?? result).length };
+    } catch {
+    }
+  }
+  return null;
+}
+async function listOpenCodeSessionsReadinessHttp({ baseUrl, directory = "", fetchImpl = globalThis.fetch } = {}) {
+  const root = normalizeOpenCodeBaseUrl(baseUrl, "");
+  if (!root || typeof fetchImpl !== "function") return null;
+  const url = openChamberUrl(root, "/session", directory ? { directory } : {});
+  const response = await fetchImpl(url, { method: "GET" });
+  const contentType = response.headers?.get?.("content-type") || "";
+  const raw = await response.text();
+  if (!response.ok) throw new Error(`OpenCode session list readiness failed with status ${response.status}.`);
+  if (responseLooksLikeHtml(contentType, raw)) throw new Error("OpenCode session list readiness returned an HTML app shell.");
+  const data = raw.trim() ? JSON.parse(raw) : [];
+  return { ok: true, method: "session_list_http", sessions: normalizeOpenCodeSessionCollection(data).length };
+}
+async function waitForOpenCodeReadiness(client, { worktree = process.cwd(), attempts = 10, delayMs = 500, opencodeBaseUrl = "", fetchImpl = globalThis.fetch } = {}) {
   let lastError = "opencode_not_ready";
   const maxAttempts = Math.max(1, Number(attempts) || 1);
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     try {
-      const sessionId = await createOpenCodeSession(client, { title: `Optima startup readiness probe ${now().toISOString()}`, directory: worktree });
-      if (await openCodeSessionExists(client, sessionId)) return { ok: true, method: "session_create_probe", sessionId, attempts: attempt };
-      lastError = "readiness_probe_session_not_visible";
+      const listed = await listOpenCodeSessionsReadiness(client, { directory: worktree }) || await listOpenCodeSessionsReadinessHttp({ baseUrl: opencodeBaseUrl, directory: worktree, fetchImpl });
+      if (listed?.ok) return { ...listed, attempts: attempt };
+      return { ok: true, skipped: true, reason: "session_list_probe_unavailable", attempts: attempt };
     } catch (error) {
       lastError = error.message || "opencode_not_ready";
     }
@@ -10929,18 +10962,9 @@ async function postClickUpLaunchFailureComment({ clickupClient, worktree, taskId
   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 });
-    return { ok: false, skipped: true, reason: "add_task_tag_unavailable", tagName };
-  }
-  try {
-    await clickupClient.addTaskTag({ taskId, tagName });
-    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_applied", taskId, reason, source, tagName });
-    return { ok: true, tagName };
-  } catch (error) {
-    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_failed", taskId, reason, source, tagName, message: error.message });
-    return { ok: false, error: error.message, tagName };
-  }
+  void clickupClient;
+  appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_skipped", taskId, reason, source, tagName, policy: "metadata_only_task_writes" });
+  return { ok: false, skipped: true, reason: "metadata_only_task_writes", tagName };
 }
 function openCodeBlockingPromptVerification(result, sessionId) {
   if (result?.__optimaPromptDelivery !== "prompt") return null;
@@ -11430,7 +11454,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...skipped });
     return skipped;
   }
-  const readiness = await waitForReadiness(openCodeClient, { worktree, now });
+  const readiness = await waitForReadiness(openCodeClient, { worktree, now, opencodeBaseUrl: config.opencode?.baseUrl });
   appendClickUpWebhookLocalLog(worktree, { type: readiness.ok ? "startup_reconciliation_readiness_ready" : "startup_reconciliation_readiness_failed", ...readiness });
   if (!readiness.ok) {
     const failed = { ok: false, skipped: true, reason: "opencode_not_ready", readiness, assigned: 0, comments: 0, ignored: 0, errors: 1, undelivered: 1, tasks: [], validation: { undelivered: 1, emptyPromptSessions: [] } };
@@ -11569,17 +11593,49 @@ function clickUpWebhookExpectedPath(config) {
     return "/";
   }
 }
-async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date(), sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery } = {}) {
+function summarizeClickUpRouteForLog(result = {}, payload = {}) {
+  return {
+    taskId: result.taskId || clickUpTaskIdFromPayload(payload || {}) || null,
+    event: clickUpEventType(payload || {}) || null,
+    eventKey: result.eventKey || clickUpWebhookEventKey(payload || {}) || null,
+    ok: result.ok === true,
+    action: result.action || null,
+    reason: result.reason || null,
+    sessionId: result.sessionId || result.replacementSessionId || null,
+    branch: result.branch || null,
+    worktree: result.worktree || null
+  };
+}
+function runClickUpWebhookRouteInBackground({ payload, config, state, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now } = {}) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_started", taskId: clickUpTaskIdFromPayload(payload || {}) || null, event: clickUpEventType(payload || {}) || null, eventKey: clickUpWebhookEventKey(payload || {}) || null, async: true, startedAt });
+  const route = Promise.resolve().then(() => routeClickUpWebhookEvent({ payload, config, state, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now })).then((result) => {
+    appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_finished", async: true, ...summarizeClickUpRouteForLog(result, payload) });
+    return result;
+  }).catch((error) => {
+    appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_failed", taskId: clickUpTaskIdFromPayload(payload || {}) || null, event: clickUpEventType(payload || {}) || null, eventKey: clickUpWebhookEventKey(payload || {}) || null, async: true, message: error.message });
+    return { ok: false, action: "error", reason: "background_route_failed", message: error.message };
+  });
+  route.catch(() => {
+  });
+  return route;
+}
+async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date(), sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, asyncRouting = false } = {}) {
   let payload = null;
   let handled = null;
   let authenticatedWebhook = false;
   let receivedAt = null;
   let activeState = state;
+  let latestPersistedState = state;
+  const persistState = (nextState) => {
+    latestPersistedState = nextState;
+    if (saveState) saveState(nextState);
+  };
   const finish = (result) => {
     handled = result;
     receivedAt ??= now();
-    const auditState = authenticatedWebhook ? { ...activeState, lastWebhookAt: receivedAt.toISOString() } : activeState;
-    if (saveState && authenticatedWebhook) saveState(auditState);
+    const auditState = authenticatedWebhook ? { ...latestPersistedState, lastWebhookAt: receivedAt.toISOString() } : latestPersistedState;
+    if (saveState && authenticatedWebhook) persistState(auditState);
     writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state: auditState, handled, payload, at: receivedAt });
     return result;
   };
@@ -11606,7 +11662,12 @@ async function handleClickUpWebhookRequest({ method = "POST", url = null, header
       return finish({ ok: false, status: 400, reason: "invalid_json" });
     }
     const receivedState = { ...activeState, lastWebhookAt: receivedAt.toISOString() };
-    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery });
+    persistState(receivedState);
+    if (asyncRouting) {
+      runClickUpWebhookRouteInBackground({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState: persistState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now });
+      return finish({ ok: true, status: 200, reason: "accepted", result: { action: "accepted", taskId: clickUpTaskIdFromPayload(payload), eventKey: clickUpWebhookEventKey(payload) } });
+    }
+    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState: persistState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery });
     return finish({ ok: result.ok, status: result.ok ? 200 : 422, result });
   } catch (error) {
     writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state, handled, error, payload, at: now() });
@@ -11683,7 +11744,8 @@ function startClickUpWebhookListener({ config, state, worktree, clickupClient, o
           worktree,
           clickupClient,
           openCodeClient,
-          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, config)
+          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, config),
+          asyncRouting: true
         });
         res.writeHead(handled.status, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: handled.ok, reason: handled.reason, result: handled.result?.action }));

package/dist/sanitize_cli.js

@@ -9985,17 +9985,11 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         body: JSON.stringify({ value })
       });
     },
-    async postTaskComment({ taskId, comment }) {
-      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/comment`, {
-        method: "POST",
-        body: JSON.stringify({ comment_text: comment })
-      });
+    async postTaskComment() {
+      throw new Error("Optima runtime does not post ClickUp task comments; use local logs for process failures.");
     },
-    async addTaskTag({ taskId, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
-      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/tag/${encodeURIComponent(tagName)}`, {
-        method: "POST",
-        body: JSON.stringify({})
-      });
+    async addTaskTag() {
+      throw new Error("Optima runtime does not add ClickUp task tags; use local logs for process failures.");
     },
     async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
       const params = new URLSearchParams();
@@ -10555,15 +10549,54 @@ async function createOpenCodeSession(client, { title, directory, agent } = {}) {
     throw error || new Error("OpenCode session create failed.");
   }
 }
-async function waitForOpenCodeReadiness(client, { worktree = process.cwd(), attempts = 10, delayMs = 500, now = () => /* @__PURE__ */ new Date() } = {}) {
-  if (typeof client?.session?.create !== "function") return { ok: true, skipped: true, reason: "session_create_probe_unavailable" };
+function normalizeOpenCodeSessionCollection(value) {
+  if (Array.isArray(value)) return value;
+  if (!isPlainObject(value)) return [];
+  for (const key of ["sessions", "items", "data", "result", "results"]) {
+    const nested = value[key];
+    if (Array.isArray(nested)) return nested;
+    if (isPlainObject(nested)) {
+      const normalized = normalizeOpenCodeSessionCollection(nested);
+      if (normalized.length > 0) return normalized;
+    }
+  }
+  return [];
+}
+async function listOpenCodeSessionsReadiness(client, { directory = "" } = {}) {
+  if (typeof client?.session?.list !== "function") return null;
+  const attempts = [
+    { query: directory ? { directory } : {} },
+    directory ? { directory } : {}
+  ];
+  for (const attempt of attempts) {
+    try {
+      const result = await client.session.list(attempt);
+      return { ok: true, method: "session_list", sessions: normalizeOpenCodeSessionCollection(result?.data ?? result).length };
+    } catch {
+    }
+  }
+  return null;
+}
+async function listOpenCodeSessionsReadinessHttp({ baseUrl, directory = "", fetchImpl = globalThis.fetch } = {}) {
+  const root = normalizeOpenCodeBaseUrl(baseUrl, "");
+  if (!root || typeof fetchImpl !== "function") return null;
+  const url = openChamberUrl(root, "/session", directory ? { directory } : {});
+  const response = await fetchImpl(url, { method: "GET" });
+  const contentType = response.headers?.get?.("content-type") || "";
+  const raw = await response.text();
+  if (!response.ok) throw new Error(`OpenCode session list readiness failed with status ${response.status}.`);
+  if (responseLooksLikeHtml(contentType, raw)) throw new Error("OpenCode session list readiness returned an HTML app shell.");
+  const data = raw.trim() ? JSON.parse(raw) : [];
+  return { ok: true, method: "session_list_http", sessions: normalizeOpenCodeSessionCollection(data).length };
+}
+async function waitForOpenCodeReadiness(client, { worktree = process.cwd(), attempts = 10, delayMs = 500, opencodeBaseUrl = "", fetchImpl = globalThis.fetch } = {}) {
   let lastError = "opencode_not_ready";
   const maxAttempts = Math.max(1, Number(attempts) || 1);
   for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
     try {
-      const sessionId = await createOpenCodeSession(client, { title: `Optima startup readiness probe ${now().toISOString()}`, directory: worktree });
-      if (await openCodeSessionExists(client, sessionId)) return { ok: true, method: "session_create_probe", sessionId, attempts: attempt };
-      lastError = "readiness_probe_session_not_visible";
+      const listed = await listOpenCodeSessionsReadiness(client, { directory: worktree }) || await listOpenCodeSessionsReadinessHttp({ baseUrl: opencodeBaseUrl, directory: worktree, fetchImpl });
+      if (listed?.ok) return { ...listed, attempts: attempt };
+      return { ok: true, skipped: true, reason: "session_list_probe_unavailable", attempts: attempt };
     } catch (error) {
       lastError = error.message || "opencode_not_ready";
     }
@@ -10936,18 +10969,9 @@ async function postClickUpLaunchFailureComment({ clickupClient, worktree, taskId
   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 });
-    return { ok: false, skipped: true, reason: "add_task_tag_unavailable", tagName };
-  }
-  try {
-    await clickupClient.addTaskTag({ taskId, tagName });
-    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_applied", taskId, reason, source, tagName });
-    return { ok: true, tagName };
-  } catch (error) {
-    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_failed", taskId, reason, source, tagName, message: error.message });
-    return { ok: false, error: error.message, tagName };
-  }
+  void clickupClient;
+  appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_skipped", taskId, reason, source, tagName, policy: "metadata_only_task_writes" });
+  return { ok: false, skipped: true, reason: "metadata_only_task_writes", tagName };
 }
 function openCodeBlockingPromptVerification(result, sessionId) {
   if (result?.__optimaPromptDelivery !== "prompt") return null;
@@ -11437,7 +11461,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...skipped });
     return skipped;
   }
-  const readiness = await waitForReadiness(openCodeClient, { worktree, now });
+  const readiness = await waitForReadiness(openCodeClient, { worktree, now, opencodeBaseUrl: config.opencode?.baseUrl });
   appendClickUpWebhookLocalLog(worktree, { type: readiness.ok ? "startup_reconciliation_readiness_ready" : "startup_reconciliation_readiness_failed", ...readiness });
   if (!readiness.ok) {
     const failed = { ok: false, skipped: true, reason: "opencode_not_ready", readiness, assigned: 0, comments: 0, ignored: 0, errors: 1, undelivered: 1, tasks: [], validation: { undelivered: 1, emptyPromptSessions: [] } };
@@ -11576,17 +11600,49 @@ function clickUpWebhookExpectedPath(config) {
     return "/";
   }
 }
-async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date(), sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery } = {}) {
+function summarizeClickUpRouteForLog(result = {}, payload = {}) {
+  return {
+    taskId: result.taskId || clickUpTaskIdFromPayload(payload || {}) || null,
+    event: clickUpEventType(payload || {}) || null,
+    eventKey: result.eventKey || clickUpWebhookEventKey(payload || {}) || null,
+    ok: result.ok === true,
+    action: result.action || null,
+    reason: result.reason || null,
+    sessionId: result.sessionId || result.replacementSessionId || null,
+    branch: result.branch || null,
+    worktree: result.worktree || null
+  };
+}
+function runClickUpWebhookRouteInBackground({ payload, config, state, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now } = {}) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_started", taskId: clickUpTaskIdFromPayload(payload || {}) || null, event: clickUpEventType(payload || {}) || null, eventKey: clickUpWebhookEventKey(payload || {}) || null, async: true, startedAt });
+  const route = Promise.resolve().then(() => routeClickUpWebhookEvent({ payload, config, state, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now })).then((result) => {
+    appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_finished", async: true, ...summarizeClickUpRouteForLog(result, payload) });
+    return result;
+  }).catch((error) => {
+    appendClickUpWebhookLocalLog(worktree, { type: "webhook_route_failed", taskId: clickUpTaskIdFromPayload(payload || {}) || null, event: clickUpEventType(payload || {}) || null, eventKey: clickUpWebhookEventKey(payload || {}) || null, async: true, message: error.message });
+    return { ok: false, action: "error", reason: "background_route_failed", message: error.message };
+  });
+  route.catch(() => {
+  });
+  return route;
+}
+async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date(), sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, asyncRouting = false } = {}) {
   let payload = null;
   let handled = null;
   let authenticatedWebhook = false;
   let receivedAt = null;
   let activeState = state;
+  let latestPersistedState = state;
+  const persistState = (nextState) => {
+    latestPersistedState = nextState;
+    if (saveState) saveState(nextState);
+  };
   const finish = (result) => {
     handled = result;
     receivedAt ??= now();
-    const auditState = authenticatedWebhook ? { ...activeState, lastWebhookAt: receivedAt.toISOString() } : activeState;
-    if (saveState && authenticatedWebhook) saveState(auditState);
+    const auditState = authenticatedWebhook ? { ...latestPersistedState, lastWebhookAt: receivedAt.toISOString() } : latestPersistedState;
+    if (saveState && authenticatedWebhook) persistState(auditState);
     writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state: auditState, handled, payload, at: receivedAt });
     return result;
   };
@@ -11613,7 +11669,12 @@ async function handleClickUpWebhookRequest({ method = "POST", url = null, header
       return finish({ ok: false, status: 400, reason: "invalid_json" });
     }
     const receivedState = { ...activeState, lastWebhookAt: receivedAt.toISOString() };
-    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery });
+    persistState(receivedState);
+    if (asyncRouting) {
+      runClickUpWebhookRouteInBackground({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState: persistState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery, now });
+      return finish({ ok: true, status: 200, reason: "accepted", result: { action: "accepted", taskId: clickUpTaskIdFromPayload(payload), eventKey: clickUpWebhookEventKey(payload) } });
+    }
+    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState: persistState, sessionExists, createSession, sendSessionEvent, ensureTaskWorktree, verifySessionEventDelivery });
     return finish({ ok: result.ok, status: result.ok ? 200 : 422, result });
   } catch (error) {
     writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state, handled, error, payload, at: now() });
@@ -11690,7 +11751,8 @@ function startClickUpWebhookListener({ config, state, worktree, clickupClient, o
           worktree,
           clickupClient,
           openCodeClient,
-          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, config)
+          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, config),
+          asyncRouting: true
         });
         res.writeHead(handled.status, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: handled.ok, reason: handled.reason, result: handled.result?.action }));

package/package.json

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