@defend-tech/opencode-optima 0.1.66 → 0.1.68

package/Agents_Common.md

@@ -13,13 +13,15 @@
 - Use the ClickUp skill and ClickUp MCP/tools for all ClickUp reads, writes, comments, field updates, status transitions, assignments, and dashboard operations; if unavailable or forbidden, state the sync blocker and leave a manual-sync payload in task/evidence.
 - Before writing ClickUp updates from local artifacts, use Optima Markdown-driven sync tools (`optima_clickup_start_task`, `optima_clickup_sync_summary`, `optima_clickup_transition`, `optima_clickup_create_subtasks`, `optima_clickup_apply_payload`) to derive payloads from `.optima` task/evidence Markdown instead of generating duplicate summaries.
 - Human-readable task/evidence summaries, validation results, AC coverage, documentation impact, blockers, reopen history, status-transition rationale, and final handoffs are the right source and must be posted to the linked ClickUp task/subtask comments or fields; subtasks come from strict plan/Definition `## Subtasks` sections via `optima_clickup_create_subtasks`.
+- ClickUp comments are human-facing model updates only. Do not post Optima runtime/process noise such as webhook events, reassignment detected, startup reconciliation, launch failure, worktree provisioning failure, or "no non-human assignee" notices.
+- ClickUp comments must use real Markdown line breaks. Never send escaped newline text like `\n` or `\\n`; if a drafted comment contains those literal sequences, regenerate it before posting.
 - WPM rewrites the ClickUp task description on initial pickup and again at plan completion with the complete current/final description of what must be done, distinct from comments.
 - Keep raw logs in evidence storage; do not paste raw logs wholesale into ClickUp. Post concise summaries, paths/links, or relevant excerpts only.
 - `product_manager` may investigate, answer, pre-estimate "a qué huele" small/medium/large plus rough story points, and operate ClickUp dashboards; development requests must be converted into properly routed ClickUp tasks.
 - ClickUp delivery types are `Tarea`, `Bug`, `Doc`, `PoC`; ignore `Idea`, legacy `Backlog` alias, `Hito`, `Nota de reunión`, and `Respuesta del formulario` unless converted or linked.
 - WPM estimates `Story Points` during `plan` and re-estimates on material plan changes.
 - Human role registry: resolve `CTO` and `PO` from `docs/core/humans.md` when present; if a task worktree lacks that file, use Optima-provided fallback role context and configured ClickUp IDs instead of blocking solely on the missing repo-local file. Use role identifiers in workflow text and code instead of personal names.
-- ClickUp status actions: `backlog` ignore, `plan` plan with `Story Points`, `Definition`, and test strategy, `in progress` execute, `validation` Tech Lead + Validator/QA gates, and parent post-approval merge automation. Assign `CTO`/`PO` only for parent `plan` questions with clear ClickUp comments, real `in progress` blockers from missing credentials/permissions/tools/access, or parent `validation` with a functional preview URL; never for generic handoff, cleanup, subtasks, or partial-phase stops. Validator/QA may merge validated subtasks into the parent branch without CTO/PO approval; parent human `Approved` comments trigger automation to remove humans, assign merge owner/self, merge to `dev`, clean workspaces/worktrees/branches, push, and ensure dev receives the code. `completed`/`Closed` ignore unless reopened.
+- ClickUp status actions: `backlog` ignore, `plan` plan with `Story Points`, `Definition`, and test strategy, `in progress` execute, `validation` Tech Lead + Validator/QA gates, and parent post-approval merge automation. Treat blockers as work to route first: spawn or resume the relevant Coder, QA, Tech Lead, or specialist subagent to diagnose and fix repo/test/env issues before escalating. Assign `CTO`/`PO` only for parent `plan` questions with clear ClickUp comments, true external `in progress` blockers from missing credentials/permissions/tools/access after attempted local resolution, or parent `validation` with a functional preview URL; never for generic handoff, cleanup, subtasks, partial-phase stops, local dependency/test failures that a subagent can fix, or "no non-human assignee" fallback. Validator/QA may merge validated subtasks into the parent branch without CTO/PO approval; parent human `Approved` comments trigger automation to remove humans, assign merge owner/self, merge to `dev`, clean workspaces/worktrees/branches, push, and ensure dev receives the code. `completed`/`Closed` ignore unless reopened.
 - One shared-worktree `implementation` task may be active; ClickUp-first delivery should use task-specific worktrees/branches.
 - Agent messages must start with `[Agent Message] From: <agent_name> To: <agent_name>`.
 - Clarifications, blockers, dependencies, and reviews go through PMA.

package/Agents_Common.prompt.md

@@ -15,13 +15,15 @@
 - Use the ClickUp skill and ClickUp MCP/tools for all ClickUp reads, writes, comments, field updates, status transitions, assignments, and dashboard operations; if unavailable or forbidden, state the sync blocker and leave a manual-sync payload in task/evidence.
 - Before writing ClickUp updates from local artifacts, use Optima Markdown-driven sync tools (`optima_clickup_start_task`, `optima_clickup_sync_summary`, `optima_clickup_transition`, `optima_clickup_create_subtasks`, `optima_clickup_apply_payload`) to derive payloads from `.optima` task/evidence Markdown instead of generating duplicate summaries.
 - Human-readable task/evidence summaries, validation results, AC coverage, documentation impact, blockers, reopen history, status-transition rationale, and final handoffs are the right source and must be posted to the linked ClickUp task/subtask comments or fields; subtasks come from strict plan/Definition `## Subtasks` sections via `optima_clickup_create_subtasks`.
+- ClickUp comments are human-facing model updates only. Do not post Optima runtime/process noise such as webhook events, reassignment detected, startup reconciliation, launch failure, worktree provisioning failure, or "no non-human assignee" notices.
+- ClickUp comments must use real Markdown line breaks. Never send escaped newline text like `\n` or `\\n`; if a drafted comment contains those literal sequences, regenerate it before posting.
 - WPM rewrites the ClickUp task description on initial pickup and again at plan completion with the complete current/final description of what must be done, distinct from comments.
 - Keep raw logs in evidence storage; do not paste raw logs wholesale into ClickUp. Post concise summaries, paths/links, or relevant excerpts only.
 - `product_manager` may investigate, answer, pre-estimate "a qué huele" small/medium/large plus rough story points, and operate ClickUp dashboards; development requests must become routed ClickUp tasks.
 - ClickUp-first delivery types: `Tarea`, `Bug`, `Doc`, `PoC`; ignore `Idea`, legacy `Backlog` alias, `Hito`, `Nota de reunión`, `Respuesta del formulario` unless converted or linked.
 - WPM estimates `Story Points` during `plan` and re-estimates on material plan changes.
 - Human role registry: resolve `CTO` and `PO` from `docs/core/humans.md` when present; if missing in a task worktree, use Optima fallback role context/configured ClickUp IDs instead of blocking solely on the missing file.
-- ClickUp-first statuses: `backlog` ignore, `plan` plan with `Story Points`, `Definition`, and test strategy, `in progress` execute, `validation` Tech Lead + Validator/QA gates, and parent post-approval merge automation. Assign `CTO`/`PO` only for parent `plan` questions with clear ClickUp comments, real `in progress` blockers from missing credentials/permissions/tools/access, or parent `validation` with a functional preview URL; never for generic handoff, cleanup, subtasks, or partial-phase stops. Validator/QA may merge validated subtasks into the parent branch without CTO/PO approval; parent human `Approved` comments trigger automation to remove humans, assign merge owner/self, merge to `dev`, clean workspaces/worktrees/branches, push, and ensure dev receives the code. `completed`/`Closed` ignore unless reopened.
+- ClickUp-first statuses: `backlog` ignore, `plan` plan with `Story Points`, `Definition`, and test strategy, `in progress` execute, `validation` Tech Lead + Validator/QA gates, and parent post-approval merge automation. Treat blockers as work to route first: spawn or resume the relevant Coder, QA, Tech Lead, or specialist subagent to diagnose and fix repo/test/env issues before escalating. Assign `CTO`/`PO` only for parent `plan` questions with clear ClickUp comments, true external `in progress` blockers from missing credentials/permissions/tools/access after attempted local resolution, or parent `validation` with a functional preview URL; never for generic handoff, cleanup, subtasks, partial-phase stops, local dependency/test failures that a subagent can fix, or "no non-human assignee" fallback. Validator/QA may merge validated subtasks into the parent branch without CTO/PO approval; parent human `Approved` comments trigger automation to remove humans, assign merge owner/self, merge to `dev`, clean workspaces/worktrees/branches, push, and ensure dev receives the code. `completed`/`Closed` ignore unless reopened.
 - Signed agent-to-agent messages must start exactly: `[Agent Message] From: <agent_name> To: <agent_name>`.
 - Direct all clarifications, blockers, and specialist questions through PMA unless explicitly in a direct discussion-capable role.
 - Read relevant docs/tasks fully when they govern the current work. Prefer targeted CodeMap navigation before broad source search.

package/assets/agents/workflow_product_manager.md

@@ -15,8 +15,9 @@ You are Workflow_Product_Manager, Optima's ClickUp-first delivery orchestrator.
 - `workflow_product_manager` owns delivery ops: ClickUp status, routing/handoffs, decomposition, validation gates, Git worktree/branch/PR flow, evidence, and closure.
 - `product_manager` remains compatibility/product/planning PMA for requirements, SCRs, product truth, rough pre-estimation, and default/legacy orchestration when ClickUp-first is not opted in. Do not remove, shadow, or break `product_manager`.
 - ClickUp Docs/tasks are source of truth for intent, state, comments, assignment, validation, and closure. Use the ClickUp skill plus ClickUp MCP/tools for every read/write/comment/field/status/assignment/dashboard action.
-- RULE NUMBER ONE: your operating objective is zero ClickUp tasks assigned to Workflow/Product Manager. If a task is PM-assigned, do not stop until you have posted a human-visible ClickUp task comment, removed yourself, and assigned the next non-human owner; assign `CTO`/`PO` only under the explicit human approval allowlist.
-- OpenCode session output is not visible to humans unless you post it to ClickUp. Before any stop, blocker, error, clarification, missing tool, or handoff pause, post a task comment. If ClickUp writes are unavailable, record the blocker/manual-sync payload in task/evidence and still report that blocker before stopping.
+- RULE NUMBER ONE: your operating objective is delivered work, not merely zero PM-assigned tasks. If a task is PM-assigned, keep it moving by resolving the next actionable blocker or delegating it to the right subagent; remove yourself only after a real next owner/session is active or after a true external blocker has been explained.
+- OpenCode session output is not visible to humans unless you post it to ClickUp. Post ClickUp comments only for useful model work updates, human questions, final handoffs, and true external blockers. Never post runtime/process noise such as webhook events, reassignment detected, startup reconciliation, launch failure, worktree provisioning failure, or "no non-human assignee" notices.
+- ClickUp comments must be readable Markdown with real line breaks. Never send escaped newline text like `\n` or `\\n`; if a drafted comment contains those literal sequences, regenerate it before posting.
 - Keep raw logs in evidence; ClickUp gets summaries, paths/links, or excerpts only.
 
 ## Definition, Mirrors, Sessions
@@ -43,7 +44,7 @@ You are Workflow_Product_Manager, Optima's ClickUp-first delivery orchestrator.
 - Human approval allowlist: never assign `CTO`/`PO` except for parent `plan` questions with clear ClickUp comments, real `in progress` blockers from missing credentials/permissions/tools/access, or parent `validation` with a functional preview URL such as `https://<taskid>-preview.defend.tech`. Do not assign them for generic handoff, routine validation, cleanup, subtasks, or partial-phase stops.
 - `backlog`: ignore until prioritized.
 - `plan`: clarify AC/SCR/test strategy with Validator/QA; decompose; create/update Definition; estimate Story Points; remove PM assignee first; assign the next delivery owner. Assign `CTO`/`PO` only for parent tasks with clear questions already posted in ClickUp comments; subtasks are planned and executed end-to-end without CTO/PO assignment.
-- `in progress`: execute through the assigned delivery agent or workflow runner. Escalate to `CTO`/`PO` only when genuinely blocked by missing credentials, permissions, external tools, or access; do not stop with phase language such as "I reached phase 1".
+- `in progress`: execute through the assigned delivery agent or workflow runner. Treat blockers as work to solve first: spawn or resume Coder for code/build/dependency failures, QA for validation/test/evidence failures, Tech Lead for architecture/review/merge failures, and the relevant specialist for domain blockers. Escalate to `CTO`/`PO` only when genuinely blocked by missing credentials, permissions, external tools, or access after local/subagent resolution attempts; do not stop with phase language such as "I reached phase 1" or "no non-human assignee is available".
 - `validation`: route Tech Lead for architecture/code/PR/standards/repo-skill review and Validator/QA for tests, Playwright/regression/coverage/evidence/final-doc checks. Validator/QA may merge validated subtasks into parent branch without `CTO`/`PO`; validated parent tasks may assign `CTO`/`PO` only when a functional preview URL is provided.
 - `merge`: parent-only post-approval automation after a human comments `Approved`; remove human assignees, assign yourself or the merge owner, merge parent PR into `dev`, clean workspaces/worktrees/branches, push to `dev`, and ensure the dev environment contains the code. Conflicts or merge failures return the affected item to `in progress`.
 - `completed` / `Closed`: no execution unless explicitly reopened.
@@ -66,7 +67,8 @@ You are Workflow_Product_Manager, Optima's ClickUp-first delivery orchestrator.
 
 - Orchestrate; do not silently implement specialist work yourself.
 - Delegate through ClickUp task/subtask assignment or task-specific specialist sessions with ClickUp context, AC, evidence, sync duties, branch target, Story Points, Definition link, final Documentation needs, and validation requirements.
-- Never abandon a PM-assigned task: keep working until unblocked and handed off, or post the stop/blocker/clarification/error as a ClickUp comment, remove Workflow/Product Manager, and assign the next delivery owner; assign `CTO`/`PO` only under the human approval allowlist.
+- Never abandon a PM-assigned task: keep working until unblocked and handed off. If blocked, first create or resume the appropriate subagent and ask it to remove the blocker; only escalate true external blockers after documenting exactly what was tried and what external input is required.
+- When a human comments or mentions `@Defend Tech Product Manager`, answer directly in the task with the requested clarification and then route the next action. Do not remove yourself merely because the human asks what is needed.
 - On pickup, rewrite the ClickUp task description with the complete current description of what must be done; do not rely on status comments.
 - At plan completion, rewrite the ClickUp task description again with the complete final plan/Definition, distinct from the plan comment.
 - Estimate Story Points during `plan`, write them to ClickUp `Story Points`, and re-estimate when material plan changes alter scope/risk.

package/dist/index.js

@@ -8527,6 +8527,8 @@ 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_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS = 6 * 60 * 60 * 1e3;
+var CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS = 5 * 60 * 1e3;
 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]";
@@ -9807,6 +9809,10 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
       startupReconciliationDelayMs: normalizeNonNegativeInteger(
         opencode.startup_reconciliation_delay_ms ?? opencode.startupReconciliationDelayMs ?? raw.startup_reconciliation_delay_ms ?? raw.startupReconciliationDelayMs,
         CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS
+      ),
+      assignmentWatchdogIntervalMs: normalizeNonNegativeInteger(
+        opencode.assignment_watchdog_interval_ms ?? opencode.assignmentWatchdogIntervalMs ?? raw.assignment_watchdog_interval_ms ?? raw.assignmentWatchdogIntervalMs,
+        CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS
       )
     },
     openchamber: {
@@ -10772,17 +10778,87 @@ function openCodeResultSummary(result) {
     status: result?.status || result?.response?.status || null
   };
 }
+function openCodeMessagePayload(message = {}) {
+  if (!isPlainObject(message)) return {};
+  const rawData = message.data;
+  if (isPlainObject(rawData)) {
+    return {
+      ...rawData,
+      id: rawData.id || message.id,
+      time_created: rawData.time_created ?? message.time_created,
+      time_updated: rawData.time_updated ?? message.time_updated
+    };
+  }
+  if (typeof rawData === "string" && rawData.trim()) {
+    try {
+      const parsed = JSON.parse(rawData);
+      if (isPlainObject(parsed)) {
+        return {
+          ...parsed,
+          id: parsed.id || message.id,
+          time_created: parsed.time_created ?? message.time_created,
+          time_updated: parsed.time_updated ?? message.time_updated
+        };
+      }
+    } catch {
+    }
+  }
+  return message;
+}
 function normalizeOpenCodeMessageRole(message = {}) {
-  return message.role || message.info?.role || message.author?.role || message.type || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.role || payload.info?.role || payload.author?.role || payload.type || "";
 }
 function normalizeOpenCodeMessageAgent(message = {}) {
-  return message.agent || message.info?.agent || message.mode?.agent || message.author?.agent || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.agent || payload.info?.agent || payload.mode?.agent || payload.author?.agent || "";
 }
 function normalizeOpenCodeMessageMode(message = {}) {
-  return message.mode || message.info?.mode || message.metadata?.mode || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.mode || payload.info?.mode || payload.metadata?.mode || "";
 }
 function normalizeOpenCodeMessageId(message = {}) {
-  return message.id || message.messageID || message.messageId || message.info?.id || message.data?.id || null;
+  const payload = openCodeMessagePayload(message);
+  return payload.id || payload.messageID || payload.messageId || payload.info?.id || payload.data?.id || message.id || null;
+}
+function openCodeMessageTimestampMs(message = {}, key = "updated") {
+  const payload = openCodeMessagePayload(message);
+  const time = payload.time || payload.info?.time || {};
+  const value = key === "completed" ? payload.time_completed ?? payload.timeCompleted ?? time.completed : key === "created" ? payload.time_created ?? payload.timeCreated ?? time.created : payload.time_updated ?? payload.timeUpdated ?? time.updated ?? payload.time_created ?? payload.timeCreated ?? time.created;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function isOpenCodeAssistantMessageRunning(message = {}) {
+  if (normalizeLooseToken(normalizeOpenCodeMessageRole(message)) !== "assistant") return false;
+  const started = openCodeMessageTimestampMs(message, "created") > 0;
+  if (!started) return false;
+  return openCodeMessageTimestampMs(message, "completed") === 0;
+}
+async function inspectOpenCodeSessionActivity(client, { sessionId, directory, limit = 10 } = {}) {
+  const messages = await readOpenCodeSessionMessages(client, { sessionId, directory, limit });
+  if (!messages) return { ok: false, reason: "message_inspection_unavailable", sessionId, directory };
+  const enriched = messages.map((message, index) => ({
+    message,
+    index,
+    sortTime: openCodeMessageTimestampMs(message, "updated") || index,
+    createdAt: openCodeMessageTimestampMs(message, "created"),
+    completedAt: openCodeMessageTimestampMs(message, "completed")
+  })).sort((a, b) => a.sortTime - b.sortTime || a.index - b.index);
+  const assistantMessages = enriched.filter((entry) => normalizeLooseToken(normalizeOpenCodeMessageRole(entry.message)) === "assistant");
+  const latestAssistant = assistantMessages.at(-1) || null;
+  const latest = enriched.at(-1) || null;
+  const running = latestAssistant ? isOpenCodeAssistantMessageRunning(latestAssistant.message) : false;
+  return {
+    ok: true,
+    sessionId,
+    directory,
+    count: messages.length,
+    running,
+    latestMessageId: latest ? normalizeOpenCodeMessageId(latest.message) : null,
+    latestAssistantMessageId: latestAssistant ? normalizeOpenCodeMessageId(latestAssistant.message) : null,
+    latestAssistantCreatedAt: latestAssistant?.createdAt || 0,
+    latestAssistantCompletedAt: latestAssistant?.completedAt || 0
+  };
 }
 function summarizeOpenCodeMessages(messages = [], { snippetLength = 160, maxMessages = 50 } = {}) {
   const list = Array.isArray(messages) ? messages.slice(0, maxMessages) : [];
@@ -10922,8 +10998,9 @@ async function probeOpenCodeSessionControl(client, { directory, agent, omitAgent
   };
 }
 function openCodeMessageText(message) {
-  const parts = [message?.text, message?.content, message?.message, message?.body?.text, message?.data?.text];
-  const partList = Array.isArray(message?.parts) ? message.parts : Array.isArray(message?.body?.parts) ? message.body.parts : [];
+  const payload = openCodeMessagePayload(message);
+  const parts = [payload?.text, payload?.content, payload?.message, payload?.body?.text, payload?.data?.text];
+  const partList = Array.isArray(payload?.parts) ? payload.parts : Array.isArray(payload?.body?.parts) ? payload.body.parts : [];
   for (const part of partList) parts.push(part?.text, part?.content);
   return parts.filter((value) => typeof value === "string").join("\n");
 }
@@ -11141,6 +11218,7 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   entry.cleaning = true;
   const cleanup = (async () => {
     clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_started", reason, key: entry.key, webhookId: entry.state?.webhookId });
+    if (entry.assignmentWatchdog?.interval) clearInterval(entry.assignmentWatchdog.interval);
     const closeResult = await closeClickUpWebhookServer(entry.listener?.server);
     if (entry.listenerRegistry && entry.listener?.key) entry.listenerRegistry.delete(entry.listener.key);
     const preservedResult = { ok: true, skipped: true, reason: "remote_webhook_preserved" };
@@ -11154,10 +11232,10 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   if (result?.timeout) clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_timeout", reason, webhookId: entry.state?.webhookId });
   return result;
 }
-function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners } = {}) {
+function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners, assignmentWatchdog = null } = {}) {
   if (!isClickUpWebhookStateActive(state, config)) return null;
   const key = managedClickUpWebhookKey({ worktree, state, config });
-  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, assignmentWatchdog, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
   activeClickUpWebhookLifecycleRegistry.set(key, entry);
   installClickUpWebhookSignalHandlers();
   clickUpWebhookLifecycleLog(worktree, { type: "lifecycle_registered", key, webhookId: state.webhookId });
@@ -11447,19 +11525,54 @@ function scheduleClickUpStartupReconciliation({ config, state = {}, worktree = p
   timer?.unref?.();
   return { scheduled: true, delayMs: normalizedDelayMs, timer };
 }
-async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
+function scheduleClickUpAssignmentWatchdog({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, scheduler = setInterval, intervalMs = config?.opencode?.assignmentWatchdogIntervalMs ?? CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS, saveState = null, reconcile = reconcileClickUpStartup } = {}) {
+  const normalizedIntervalMs = normalizeNonNegativeInteger(intervalMs, CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS);
+  if (!normalizedIntervalMs) {
+    clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_disabled", webhookId: state?.webhookId || null });
+    return { scheduled: false, intervalMs: 0, reason: "disabled" };
+  }
+  let running = false;
+  const run = () => {
+    if (running) {
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_tick_skipped", reason: "previous_tick_running" });
+      return;
+    }
+    running = true;
+    const latestState = readClickUpWebhookState(worktree, config);
+    Promise.resolve().then(() => reconcile({
+      config,
+      state: latestState?.webhookId ? latestState : state,
+      worktree,
+      clickupClient,
+      openCodeClient,
+      saveState,
+      assignmentMode: "watchdog"
+    })).catch((error) => {
+      clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+    }).finally(() => {
+      running = false;
+    });
+  };
+  const interval = scheduler(run, normalizedIntervalMs);
+  interval?.unref?.();
+  clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_scheduled", intervalMs: normalizedIntervalMs, webhookId: state?.webhookId || null });
+  return { scheduled: true, intervalMs: normalizedIntervalMs, interval };
+}
+async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT, assignmentMode = "startup" } = {}) {
+  const watchdogMode = assignmentMode === "watchdog";
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_started" : "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
   if (!config || !clickupClient?.listAssignedTasks) {
     const skipped = { ok: true, skipped: true, reason: "clickup_task_listing_unavailable", assigned: 0, comments: 0 };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...skipped });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...skipped });
     return skipped;
   }
   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: [] } };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_failed", reason: failed.reason, readiness });
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...failed });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_failed" : "startup_reconciliation_failed", reason: failed.reason, readiness });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...failed });
     return failed;
   }
   let authorizedUserId = "";
@@ -11477,6 +11590,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     if (saveState) saveState(nextState);
   };
   const lastWebhookMs = clickUpTimestampMs(mutableState.lastWebhookAt);
+  const startupCommentStartMs = lastWebhookMs || Math.max(0, now().getTime() - CLICKUP_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS);
   const ignored = new Set((config.routing?.ignoredStatuses || CLICKUP_WEBHOOK_TERMINAL_STATUSES).map(normalizeClickUpStatus));
   const routed = { assigned: 0, comments: 0, ignored: 0, errors: 0, undelivered: 0, tasks: [] };
   const listed = await clickupClient.listAssignedTasks({ assigneeId: config.routing.productManagerAssigneeId, limit });
@@ -11495,9 +11609,29 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       routed.ignored += 1;
       continue;
     }
+    if (watchdogMode) {
+      const existingMetadata = clickUpTaskAgentMetadata(task, config.routing.metadataFieldId);
+      const metadata = normalizeAgentMetadataJson(existingMetadata);
+      const rawSessionId = getNestedMetadataValue(metadata, config.routing.metadataKey);
+      const sessionId = typeof rawSessionId === "string" && rawSessionId.startsWith("ses_") ? rawSessionId : "";
+      const directory = String(getNestedMetadataValue(metadata, "task.worktree") || "").trim();
+      if (sessionId) {
+        try {
+          const activity = await inspectOpenCodeSessionActivity(openCodeClient, { sessionId, directory });
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity", taskId, sessionId, directory: directory || null, ...activity });
+          if (activity.running) {
+            routed.ignored += 1;
+            routed.tasks.push({ taskId, action: "ignored", ok: true, sessionId, branch: getNestedMetadataValue(metadata, "task.branch") || null, worktree: directory || null, verification: "session_running", delivered: false });
+            continue;
+          }
+        } catch (error) {
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity_failed", taskId, sessionId, directory: directory || null, message: error.message });
+        }
+      }
+    }
     try {
       const result = await routeClickUpWebhookEvent({
-        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true },
+        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true, assignment_watchdog: watchdogMode },
         config,
         state: mutableState,
         worktree,
@@ -11547,12 +11681,12 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: "error", sessionId: null, reason: "startup_reconciliation_task_failed" });
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_task_failed", source: "startup_reconciliation_task" });
     }
-    if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
+    if (!startupCommentStartMs || !clickupClient?.getTaskComments) continue;
     try {
-      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: lastWebhookMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
+      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: startupCommentStartMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
       for (const comment of clickUpCommentListItems(commentsResponse).slice(0, CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT)) {
         const commentMs = clickUpCommentUpdatedMs(comment);
-        if (!commentMs || commentMs <= lastWebhookMs) continue;
+        if (!commentMs || commentMs <= startupCommentStartMs) continue;
         const authorId = clickUpCommentAuthorId(comment);
         if (authorId && (authorId === config.routing.ignoredCommentAuthorId || authorId === authorizedUserId)) continue;
         if (!clickUpCommentMentionsProductManager(comment, config.routing)) continue;
@@ -11579,11 +11713,11 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_comments_failed", source: "startup_reconciliation_comments" });
     }
   }
-  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId);
+  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId && task.verification !== "session_running");
   if (emptyPromptSessions.length > 0) {
     appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_validation_failed", tasks: emptyPromptSessions });
   }
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...routed });
   return { ok: routed.errors === 0 && routed.undelivered === 0, ...routed, validation: { undelivered: routed.undelivered, emptyPromptSessions } };
 }
 function clickUpWebhookExpectedPath(config) {
@@ -11593,17 +11727,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;
   };
@@ -11630,7 +11796,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() });
@@ -11707,7 +11878,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 }));
@@ -12859,7 +13031,17 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
           ...listenerState,
           listener: { bindHost: clickUpWebhookValidation.config.webhook.bindHost, bindPort: clickUpWebhookValidation.config.webhook.bindPort, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
         }, clickUpWebhookValidation.config);
-        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry });
+        const assignmentWatchdog = scheduleClickUpAssignmentWatchdog({
+          config: clickUpWebhookValidation.config,
+          state: activeState,
+          worktree,
+          clickupClient: lifecycleClickUpClient,
+          openCodeClient: input.client,
+          scheduler: input.assignmentWatchdogScheduler,
+          intervalMs: input.assignmentWatchdogIntervalMs,
+          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, clickUpWebhookValidation.config)
+        });
+        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry, assignmentWatchdog });
         scheduleClickUpStartupReconciliation({
           config: clickUpWebhookValidation.config,
           state: activeState,
@@ -13515,7 +13697,7 @@ Follow-up: use optima_prompt_workflow with session_id '${sessionId}' to check in
     }
   };
 }
-OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
+OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, inspectOpenCodeSessionActivity, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpAssignmentWatchdog, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
 export {
   OptimaPlugin as default
 };

package/dist/sanitize_cli.js

@@ -8534,6 +8534,8 @@ 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_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS = 6 * 60 * 60 * 1e3;
+var CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS = 5 * 60 * 1e3;
 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]";
@@ -9814,6 +9816,10 @@ function normalizeClickUpWebhookConfig(rawClickUp = null, worktree = process.cwd
       startupReconciliationDelayMs: normalizeNonNegativeInteger(
         opencode.startup_reconciliation_delay_ms ?? opencode.startupReconciliationDelayMs ?? raw.startup_reconciliation_delay_ms ?? raw.startupReconciliationDelayMs,
         CLICKUP_WEBHOOK_STARTUP_RECONCILIATION_DELAY_MS
+      ),
+      assignmentWatchdogIntervalMs: normalizeNonNegativeInteger(
+        opencode.assignment_watchdog_interval_ms ?? opencode.assignmentWatchdogIntervalMs ?? raw.assignment_watchdog_interval_ms ?? raw.assignmentWatchdogIntervalMs,
+        CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS
       )
     },
     openchamber: {
@@ -10779,17 +10785,87 @@ function openCodeResultSummary(result) {
     status: result?.status || result?.response?.status || null
   };
 }
+function openCodeMessagePayload(message = {}) {
+  if (!isPlainObject(message)) return {};
+  const rawData = message.data;
+  if (isPlainObject(rawData)) {
+    return {
+      ...rawData,
+      id: rawData.id || message.id,
+      time_created: rawData.time_created ?? message.time_created,
+      time_updated: rawData.time_updated ?? message.time_updated
+    };
+  }
+  if (typeof rawData === "string" && rawData.trim()) {
+    try {
+      const parsed = JSON.parse(rawData);
+      if (isPlainObject(parsed)) {
+        return {
+          ...parsed,
+          id: parsed.id || message.id,
+          time_created: parsed.time_created ?? message.time_created,
+          time_updated: parsed.time_updated ?? message.time_updated
+        };
+      }
+    } catch {
+    }
+  }
+  return message;
+}
 function normalizeOpenCodeMessageRole(message = {}) {
-  return message.role || message.info?.role || message.author?.role || message.type || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.role || payload.info?.role || payload.author?.role || payload.type || "";
 }
 function normalizeOpenCodeMessageAgent(message = {}) {
-  return message.agent || message.info?.agent || message.mode?.agent || message.author?.agent || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.agent || payload.info?.agent || payload.mode?.agent || payload.author?.agent || "";
 }
 function normalizeOpenCodeMessageMode(message = {}) {
-  return message.mode || message.info?.mode || message.metadata?.mode || "";
+  const payload = openCodeMessagePayload(message);
+  return payload.mode || payload.info?.mode || payload.metadata?.mode || "";
 }
 function normalizeOpenCodeMessageId(message = {}) {
-  return message.id || message.messageID || message.messageId || message.info?.id || message.data?.id || null;
+  const payload = openCodeMessagePayload(message);
+  return payload.id || payload.messageID || payload.messageId || payload.info?.id || payload.data?.id || message.id || null;
+}
+function openCodeMessageTimestampMs(message = {}, key = "updated") {
+  const payload = openCodeMessagePayload(message);
+  const time = payload.time || payload.info?.time || {};
+  const value = key === "completed" ? payload.time_completed ?? payload.timeCompleted ?? time.completed : key === "created" ? payload.time_created ?? payload.timeCreated ?? time.created : payload.time_updated ?? payload.timeUpdated ?? time.updated ?? payload.time_created ?? payload.timeCreated ?? time.created;
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+function isOpenCodeAssistantMessageRunning(message = {}) {
+  if (normalizeLooseToken(normalizeOpenCodeMessageRole(message)) !== "assistant") return false;
+  const started = openCodeMessageTimestampMs(message, "created") > 0;
+  if (!started) return false;
+  return openCodeMessageTimestampMs(message, "completed") === 0;
+}
+async function inspectOpenCodeSessionActivity(client, { sessionId, directory, limit = 10 } = {}) {
+  const messages = await readOpenCodeSessionMessages(client, { sessionId, directory, limit });
+  if (!messages) return { ok: false, reason: "message_inspection_unavailable", sessionId, directory };
+  const enriched = messages.map((message, index) => ({
+    message,
+    index,
+    sortTime: openCodeMessageTimestampMs(message, "updated") || index,
+    createdAt: openCodeMessageTimestampMs(message, "created"),
+    completedAt: openCodeMessageTimestampMs(message, "completed")
+  })).sort((a, b) => a.sortTime - b.sortTime || a.index - b.index);
+  const assistantMessages = enriched.filter((entry) => normalizeLooseToken(normalizeOpenCodeMessageRole(entry.message)) === "assistant");
+  const latestAssistant = assistantMessages.at(-1) || null;
+  const latest = enriched.at(-1) || null;
+  const running = latestAssistant ? isOpenCodeAssistantMessageRunning(latestAssistant.message) : false;
+  return {
+    ok: true,
+    sessionId,
+    directory,
+    count: messages.length,
+    running,
+    latestMessageId: latest ? normalizeOpenCodeMessageId(latest.message) : null,
+    latestAssistantMessageId: latestAssistant ? normalizeOpenCodeMessageId(latestAssistant.message) : null,
+    latestAssistantCreatedAt: latestAssistant?.createdAt || 0,
+    latestAssistantCompletedAt: latestAssistant?.completedAt || 0
+  };
 }
 function summarizeOpenCodeMessages(messages = [], { snippetLength = 160, maxMessages = 50 } = {}) {
   const list = Array.isArray(messages) ? messages.slice(0, maxMessages) : [];
@@ -10929,8 +11005,9 @@ async function probeOpenCodeSessionControl(client, { directory, agent, omitAgent
   };
 }
 function openCodeMessageText(message) {
-  const parts = [message?.text, message?.content, message?.message, message?.body?.text, message?.data?.text];
-  const partList = Array.isArray(message?.parts) ? message.parts : Array.isArray(message?.body?.parts) ? message.body.parts : [];
+  const payload = openCodeMessagePayload(message);
+  const parts = [payload?.text, payload?.content, payload?.message, payload?.body?.text, payload?.data?.text];
+  const partList = Array.isArray(payload?.parts) ? payload.parts : Array.isArray(payload?.body?.parts) ? payload.body.parts : [];
   for (const part of partList) parts.push(part?.text, part?.content);
   return parts.filter((value) => typeof value === "string").join("\n");
 }
@@ -11148,6 +11225,7 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   entry.cleaning = true;
   const cleanup = (async () => {
     clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_started", reason, key: entry.key, webhookId: entry.state?.webhookId });
+    if (entry.assignmentWatchdog?.interval) clearInterval(entry.assignmentWatchdog.interval);
     const closeResult = await closeClickUpWebhookServer(entry.listener?.server);
     if (entry.listenerRegistry && entry.listener?.key) entry.listenerRegistry.delete(entry.listener.key);
     const preservedResult = { ok: true, skipped: true, reason: "remote_webhook_preserved" };
@@ -11161,10 +11239,10 @@ async function cleanupManagedClickUpWebhook(entry = {}, { timeoutMs = CLICKUP_WE
   if (result?.timeout) clickUpWebhookLifecycleLog(entry.worktree, { type: "cleanup_timeout", reason, webhookId: entry.state?.webhookId });
   return result;
 }
-function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners } = {}) {
+function registerClickUpWebhookLifecycle({ config, state, worktree, clickupClient, listener, listenerRegistry = activeClickUpWebhookListeners, assignmentWatchdog = null } = {}) {
   if (!isClickUpWebhookStateActive(state, config)) return null;
   const key = managedClickUpWebhookKey({ worktree, state, config });
-  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  const entry = { key, config, state, worktree, clickupClient, listener, listenerRegistry, assignmentWatchdog, registeredAt: (/* @__PURE__ */ new Date()).toISOString() };
   activeClickUpWebhookLifecycleRegistry.set(key, entry);
   installClickUpWebhookSignalHandlers();
   clickUpWebhookLifecycleLog(worktree, { type: "lifecycle_registered", key, webhookId: state.webhookId });
@@ -11454,19 +11532,54 @@ function scheduleClickUpStartupReconciliation({ config, state = {}, worktree = p
   timer?.unref?.();
   return { scheduled: true, delayMs: normalizedDelayMs, timer };
 }
-async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
+function scheduleClickUpAssignmentWatchdog({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, scheduler = setInterval, intervalMs = config?.opencode?.assignmentWatchdogIntervalMs ?? CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS, saveState = null, reconcile = reconcileClickUpStartup } = {}) {
+  const normalizedIntervalMs = normalizeNonNegativeInteger(intervalMs, CLICKUP_ASSIGNMENT_WATCHDOG_INTERVAL_MS);
+  if (!normalizedIntervalMs) {
+    clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_disabled", webhookId: state?.webhookId || null });
+    return { scheduled: false, intervalMs: 0, reason: "disabled" };
+  }
+  let running = false;
+  const run = () => {
+    if (running) {
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_tick_skipped", reason: "previous_tick_running" });
+      return;
+    }
+    running = true;
+    const latestState = readClickUpWebhookState(worktree, config);
+    Promise.resolve().then(() => reconcile({
+      config,
+      state: latestState?.webhookId ? latestState : state,
+      worktree,
+      clickupClient,
+      openCodeClient,
+      saveState,
+      assignmentMode: "watchdog"
+    })).catch((error) => {
+      clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+      appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_failed", message: error.message });
+    }).finally(() => {
+      running = false;
+    });
+  };
+  const interval = scheduler(run, normalizedIntervalMs);
+  interval?.unref?.();
+  clickUpWebhookLifecycleLog(worktree, { type: "assignment_watchdog_scheduled", intervalMs: normalizedIntervalMs, webhookId: state?.webhookId || null });
+  return { scheduled: true, intervalMs: normalizedIntervalMs, interval };
+}
+async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, waitForReadiness = waitForOpenCodeReadiness, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT, assignmentMode = "startup" } = {}) {
+  const watchdogMode = assignmentMode === "watchdog";
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_started" : "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
   if (!config || !clickupClient?.listAssignedTasks) {
     const skipped = { ok: true, skipped: true, reason: "clickup_task_listing_unavailable", assigned: 0, comments: 0 };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...skipped });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...skipped });
     return skipped;
   }
   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: [] } };
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_failed", reason: failed.reason, readiness });
-    clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...failed });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_failed" : "startup_reconciliation_failed", reason: failed.reason, readiness });
+    clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...failed });
     return failed;
   }
   let authorizedUserId = "";
@@ -11484,6 +11597,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     if (saveState) saveState(nextState);
   };
   const lastWebhookMs = clickUpTimestampMs(mutableState.lastWebhookAt);
+  const startupCommentStartMs = lastWebhookMs || Math.max(0, now().getTime() - CLICKUP_WEBHOOK_STARTUP_COMMENT_LOOKBACK_MS);
   const ignored = new Set((config.routing?.ignoredStatuses || CLICKUP_WEBHOOK_TERMINAL_STATUSES).map(normalizeClickUpStatus));
   const routed = { assigned: 0, comments: 0, ignored: 0, errors: 0, undelivered: 0, tasks: [] };
   const listed = await clickupClient.listAssignedTasks({ assigneeId: config.routing.productManagerAssigneeId, limit });
@@ -11502,9 +11616,29 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       routed.ignored += 1;
       continue;
     }
+    if (watchdogMode) {
+      const existingMetadata = clickUpTaskAgentMetadata(task, config.routing.metadataFieldId);
+      const metadata = normalizeAgentMetadataJson(existingMetadata);
+      const rawSessionId = getNestedMetadataValue(metadata, config.routing.metadataKey);
+      const sessionId = typeof rawSessionId === "string" && rawSessionId.startsWith("ses_") ? rawSessionId : "";
+      const directory = String(getNestedMetadataValue(metadata, "task.worktree") || "").trim();
+      if (sessionId) {
+        try {
+          const activity = await inspectOpenCodeSessionActivity(openCodeClient, { sessionId, directory });
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity", taskId, sessionId, directory: directory || null, ...activity });
+          if (activity.running) {
+            routed.ignored += 1;
+            routed.tasks.push({ taskId, action: "ignored", ok: true, sessionId, branch: getNestedMetadataValue(metadata, "task.branch") || null, worktree: directory || null, verification: "session_running", delivered: false });
+            continue;
+          }
+        } catch (error) {
+          appendClickUpWebhookLocalLog(worktree, { type: "assignment_watchdog_session_activity_failed", taskId, sessionId, directory: directory || null, message: error.message });
+        }
+      }
+    }
     try {
       const result = await routeClickUpWebhookEvent({
-        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true },
+        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true, assignment_watchdog: watchdogMode },
         config,
         state: mutableState,
         worktree,
@@ -11554,12 +11688,12 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_undelivered", taskId, action: "error", sessionId: null, reason: "startup_reconciliation_task_failed" });
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_task_failed", source: "startup_reconciliation_task" });
     }
-    if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
+    if (!startupCommentStartMs || !clickupClient?.getTaskComments) continue;
     try {
-      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: lastWebhookMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
+      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: startupCommentStartMs, limit: CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT });
       for (const comment of clickUpCommentListItems(commentsResponse).slice(0, CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT)) {
         const commentMs = clickUpCommentUpdatedMs(comment);
-        if (!commentMs || commentMs <= lastWebhookMs) continue;
+        if (!commentMs || commentMs <= startupCommentStartMs) continue;
         const authorId = clickUpCommentAuthorId(comment);
         if (authorId && (authorId === config.routing.ignoredCommentAuthorId || authorId === authorizedUserId)) continue;
         if (!clickUpCommentMentionsProductManager(comment, config.routing)) continue;
@@ -11586,11 +11720,11 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_comments_failed", source: "startup_reconciliation_comments" });
     }
   }
-  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId);
+  const emptyPromptSessions = routed.tasks.filter((task) => task.delivered === false && task.sessionId && task.verification !== "session_running");
   if (emptyPromptSessions.length > 0) {
     appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_validation_failed", tasks: emptyPromptSessions });
   }
-  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
+  clickUpWebhookLifecycleLog(worktree, { type: watchdogMode ? "assignment_watchdog_finished" : "startup_reconciliation_finished", ...routed });
   return { ok: routed.errors === 0 && routed.undelivered === 0, ...routed, validation: { undelivered: routed.undelivered, emptyPromptSessions } };
 }
 function clickUpWebhookExpectedPath(config) {
@@ -11600,17 +11734,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;
   };
@@ -11637,7 +11803,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() });
@@ -11714,7 +11885,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 }));
@@ -12866,7 +13038,17 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
           ...listenerState,
           listener: { bindHost: clickUpWebhookValidation.config.webhook.bindHost, bindPort: clickUpWebhookValidation.config.webhook.bindPort, startedAt: (/* @__PURE__ */ new Date()).toISOString() }
         }, clickUpWebhookValidation.config);
-        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry });
+        const assignmentWatchdog = scheduleClickUpAssignmentWatchdog({
+          config: clickUpWebhookValidation.config,
+          state: activeState,
+          worktree,
+          clickupClient: lifecycleClickUpClient,
+          openCodeClient: input.client,
+          scheduler: input.assignmentWatchdogScheduler,
+          intervalMs: input.assignmentWatchdogIntervalMs,
+          saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, clickUpWebhookValidation.config)
+        });
+        registerClickUpWebhookLifecycle({ config: clickUpWebhookValidation.config, state: activeState, worktree, clickupClient: lifecycleClickUpClient, listener: readyListener, listenerRegistry, assignmentWatchdog });
         scheduleClickUpStartupReconciliation({
           config: clickUpWebhookValidation.config,
           state: activeState,
@@ -13522,7 +13704,7 @@ Follow-up: use optima_prompt_workflow with session_id '${sessionId}' to check in
     }
   };
 }
-OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
+OptimaPlugin.__internals = { BUNDLE_AGENTS_DIR, BUNDLE_ASSETS_DIR, CLICKUP_DEFINITION_DOC_PARENT, activeClickUpWebhookLifecycleRegistry, cleanupManagedClickUpWebhook, deleteClickUpWebhookBestEffort, BUNDLE_POLICIES_DIR, buildClickUpApplyPayloadResult, buildClickUpCreateSubtasksPayload, buildClickUpStartTaskPayload, buildClickUpSummaryPayload, buildClickUpTransitionPayload, buildOptimaAgents, clickUpCommentLedgerKey, clickUpCommentMentionsProductManager, clickUpWebhookAuditLogDir, clickUpWebhookAuditLogPath, compactPromptPath, createClickUpApiClient, createTestClickUpApiClient, createOpenCodeSession, createOpenCodeSessionControl, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpTaskWorktreeForWebhook, ensureClickUpTaskWorktreeOpenChamber, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, inspectOpenCodeSessionActivity, isClickUpDerivedWorktreeSibling, isClickUpSubtaskRoute, isClickUpWebhookStateActive, isSameOrNestedPath, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, openCodeSessionExists, promptOpenCodeSessionControl, probeOpenCodeSessionControl, readClickUpCommentLedger, readClickUpWebhookState, readOpenCodeSessionControl, readOpenCodeSessionMessages, reconcileClickUpStartup, registerOpenChamberClickUpWorktree, scheduleClickUpAssignmentWatchdog, scheduleClickUpStartupReconciliation, syncOpenChamberWorktreeVisibility, waitForOpenCodeReadiness, recordClickUpCommentVersionProcessed, resyncClickUpWebhookForSignatureDrift, resolveIncludeFile, resolveIncludes, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, summarizeOpenCodeMessages, verifyOpenCodeSessionEventDelivery, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatRepairResult, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, optimaRepairDependencies, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, planOptimaRepair, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
 
 // src/sanitize_cli.js
 var { migrateLegacyOptimaLayout: migrateLegacyOptimaLayout2 } = OptimaPlugin.__internals;

package/package.json

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