@defend-tech/opencode-optima 0.1.35 → 0.1.37

package/dist/index.js

@@ -7935,6 +7935,8 @@ var CLICKUP_PM_MENTION_NAME = "Defend Tech Product Manager";
 var CLICKUP_WEBHOOK_RUNTIME_VERSION = 1;
 var CLICKUP_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
+var CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT = 50;
+var CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT = 100;
 var CLICKUP_WEBHOOK_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "info", "verbose"]);
 var CLICKUP_WEBHOOK_REDACTED = "[REDACTED]";
 var DISCUSSION_BACKFILL_FETCH_LIMIT = 100;
@@ -9053,6 +9055,7 @@ function sanitizeClickUpWebhookState(state = {}, config = null) {
     lastValidatedAt: state.lastValidatedAt || null,
     listener: isPlainObject(state.listener) ? state.listener : {},
     pendingSessions: isPlainObject(state.pendingSessions) ? state.pendingSessions : {},
+    lastWebhookAt: state.lastWebhookAt || state.last_webhook_at || null,
     recentEventKeys
   };
 }
@@ -9135,6 +9138,9 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
     async deleteWebhook(webhookId) {
       return request(`https://api.clickup.com/api/v2/webhook/${encodeURIComponent(webhookId)}`, { method: "DELETE" });
     },
+    async getAuthorizedUser() {
+      return request("https://api.clickup.com/api/v2/user");
+    },
     async getTask(taskId) {
       return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}`);
     },
@@ -9149,6 +9155,20 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         method: "POST",
         body: JSON.stringify({ comment_text: comment })
       });
+    },
+    async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
+      const params = new URLSearchParams();
+      if (assigneeId) params.append("assignees[]", assigneeId);
+      for (const status of statuses) if (status) params.append("statuses[]", status);
+      if (limit) params.append("limit", String(limit));
+      return request(`https://api.clickup.com/api/v2/team/${encodeURIComponent(config.teamId)}/task?${params.toString()}`);
+    },
+    async getTaskComments({ taskId, start, limit = CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT } = {}) {
+      const params = new URLSearchParams();
+      if (start) params.set("start", String(start));
+      if (limit) params.set("limit", String(limit));
+      const suffix = params.toString() ? `?${params.toString()}` : "";
+      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/comment${suffix}`);
     }
   };
 }
@@ -9378,6 +9398,31 @@ function recordClickUpCommentVersionProcessed({ ledgerPath, key, taskId, eventTy
 function clickUpTaskIdFromPayload(payload = {}) {
   return String(payload.task_id || payload.taskId || payload.task?.id || payload.task?.task_id || "").trim();
 }
+function clickUpTaskListItems(response = {}) {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response.tasks)) return response.tasks;
+  if (Array.isArray(response.data)) return response.data;
+  if (Array.isArray(response?.data?.tasks)) return response.data.tasks;
+  return [];
+}
+function clickUpCommentListItems(response = {}) {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response.comments)) return response.comments;
+  if (Array.isArray(response.data)) return response.data;
+  if (Array.isArray(response?.data?.comments)) return response.data.comments;
+  return [];
+}
+function clickUpTimestampMs(value) {
+  if (value === null || value === void 0 || value === "") return 0;
+  if (value instanceof Date) return value.getTime();
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric < 1e10 ? numeric * 1e3 : numeric;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function clickUpCommentUpdatedMs(comment = {}) {
+  return clickUpTimestampMs(comment.date_updated || comment.dateUpdated || comment.updated_at || comment.updatedAt || comment.date || comment.date_created || comment.created_at);
+}
 function clickUpTaskName(task = {}) {
   return String(task?.name || "").trim();
 }
@@ -9571,6 +9616,45 @@ function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", w
     deliveryEvidencePath ? `Final merge-trackable evidence must be written under ${deliveryEvidencePath}; use .optima only as local mirror/staging.` : null
   ].filter((part) => part !== null).join("\n");
 }
+function clickUpNoAbandonmentRuleText() {
+  return "No-abandonment rule: PM must keep working, or before stopping must post a ClickUp comment, hand off, remove PM as assignee, and assign the next owner.";
+}
+function buildClickUpStartupResumeComment({ taskId, result = {} } = {}) {
+  const contextParts = [
+    result.branch ? `- Branch: ${result.branch}` : null,
+    result.worktree ? `- Worktree: ${result.worktree}` : null,
+    result.deliveryEvidencePath ? `- Delivery evidence path: ${result.deliveryEvidencePath}` : null,
+    result.evidencePath ? `- Local evidence path: ${result.evidencePath}` : null
+  ].filter(Boolean);
+  return [
+    `Startup reconciliation resumed ClickUp task ${taskId}.`,
+    `Route result: ${result.action || "unknown"}${result.ok === false ? " (failed)" : ""}.`,
+    result.sessionId ? `Session id: ${result.sessionId}.` : "Session id: unavailable.",
+    contextParts.length ? contextParts.join("\n") : "Worktree/branch/delivery evidence path: unavailable.",
+    clickUpNoAbandonmentRuleText()
+  ].join("\n");
+}
+function buildClickUpStartupBlockerComment({ taskId, error } = {}) {
+  const summary = error?.message || String(error || "unknown error");
+  return [
+    `Startup reconciliation blocker for ClickUp task ${taskId}: ${summary}`,
+    "Optima skipped this task for this startup pass and continued with the next PM-assigned task.",
+    clickUpNoAbandonmentRuleText()
+  ].join("\n");
+}
+async function postClickUpStartupComment({ clickupClient, worktree, taskId, comment, type } = {}) {
+  if (typeof clickupClient?.postTaskComment !== "function") {
+    appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comment_unavailable", taskId, commentType: type });
+    return { ok: false, skipped: true, reason: "post_task_comment_unavailable" };
+  }
+  try {
+    await clickupClient.postTaskComment({ taskId, comment });
+    return { ok: true };
+  } catch (error) {
+    appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comment_failed", taskId, commentType: type, message: error.message });
+    return { ok: false, error: error.message };
+  }
+}
 function appendClickUpWebhookLocalLog(worktree, entry) {
   const logPath = clickUpWebhookLogPath(worktree);
   fs2.mkdirSync(path2.dirname(logPath), { recursive: true });
@@ -9842,24 +9926,128 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
     stateToPersist = { ...stateToPersist, pendingSessions: remainingPending };
-    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey });
+    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
   }
   const sessionId = String(existingSessionId);
   if (await sessionExists(openCodeClient, sessionId)) {
     if (typeof clickupClient?.updateTaskMetadata === "function") await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: metadataWithRouting });
     await sendSessionEvent(openCodeClient, { sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl });
-    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey });
+    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
   }
   const at = now().toISOString();
   const incidentComment = `Optima webhook could not route this ClickUp event because OpenCode session ${sessionId} is missing on host ${host} at ${at}. No replacement session was created automatically.`;
   appendClickUpWebhookLocalLog(worktree, { type: "missing_session", taskId, sessionId, host, at });
   await clickupClient.postTaskComment({ taskId, comment: incidentComment });
-  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey });
+  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
 }
 async function routeClickUpWebhookEvent(options = {}) {
   const taskId = clickUpTaskIdFromPayload(options.payload || {});
   return withClickUpTaskRouteLock(taskId, () => routeClickUpWebhookEventUnlocked(options));
 }
+async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
+  if (!config || !clickupClient?.listAssignedTasks) return { ok: true, skipped: true, reason: "clickup_task_listing_unavailable", assigned: 0, comments: 0 };
+  let authorizedUserId = "";
+  if (clickupClient?.getAuthorizedUser) {
+    try {
+      const userResponse = await clickupClient.getAuthorizedUser();
+      authorizedUserId = String(userResponse?.user?.id || userResponse?.id || "").trim();
+    } catch (error) {
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_user_lookup_failed", message: error.message });
+    }
+  }
+  let mutableState = state;
+  const persistState = (nextState) => {
+    mutableState = nextState;
+    if (saveState) saveState(nextState);
+  };
+  const lastWebhookMs = clickUpTimestampMs(mutableState.lastWebhookAt);
+  const ignored = new Set((config.routing?.ignoredStatuses || CLICKUP_WEBHOOK_TERMINAL_STATUSES).map(normalizeClickUpStatus));
+  const routed = { assigned: 0, comments: 0, ignored: 0, errors: 0 };
+  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
+  const listed = await clickupClient.listAssignedTasks({ assigneeId: config.routing.productManagerAssigneeId, limit });
+  const tasks = clickUpTaskListItems(listed).slice(0, limit);
+  for (const task of tasks) {
+    const taskId = String(task?.id || task?.task_id || task?.taskId || "").trim();
+    if (!taskId) {
+      routed.ignored += 1;
+      continue;
+    }
+    if (ignored.has(normalizeClickUpStatus(clickUpTaskStatus(task)))) {
+      routed.ignored += 1;
+      continue;
+    }
+    if (!isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId)) {
+      routed.ignored += 1;
+      continue;
+    }
+    try {
+      const result = await routeClickUpWebhookEvent({
+        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true },
+        config,
+        state: mutableState,
+        worktree,
+        clickupClient,
+        openCodeClient,
+        sessionExists,
+        createSession,
+        sendSessionEvent,
+        saveState: persistState,
+        now
+      });
+      if (result?.ok && result.action !== "ignored") {
+        routed.assigned += 1;
+        await postClickUpStartupComment({
+          clickupClient,
+          worktree,
+          taskId,
+          type: "resume",
+          comment: buildClickUpStartupResumeComment({ taskId, result })
+        });
+      }
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_failed", taskId, message: error.message });
+      await postClickUpStartupComment({
+        clickupClient,
+        worktree,
+        taskId,
+        type: "blocker",
+        comment: buildClickUpStartupBlockerComment({ taskId, error })
+      });
+    }
+    if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
+    try {
+      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: lastWebhookMs, 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;
+        const authorId = clickUpCommentAuthorId(comment);
+        if (authorId && (authorId === config.routing.ignoredCommentAuthorId || authorId === authorizedUserId)) continue;
+        if (!clickUpCommentMentionsProductManager(comment, config.routing)) continue;
+        const event = comment.date_updated || comment.dateUpdated || comment.updated_at || comment.updatedAt ? "taskCommentUpdated" : "taskCommentPosted";
+        const result = await routeClickUpWebhookEvent({
+          payload: { webhook_id: mutableState.webhookId || "startup", event, task_id: taskId, task, comment, history_item: { id: `startup-${taskId}-${comment.id || commentMs}` }, startup_reconciliation: true },
+          config,
+          state: mutableState,
+          worktree,
+          clickupClient,
+          openCodeClient,
+          sessionExists,
+          createSession,
+          sendSessionEvent,
+          saveState: persistState,
+          now
+        });
+        if (result?.ok && result.action !== "ignored") routed.comments += 1;
+      }
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comments_failed", taskId, message: error.message });
+    }
+  }
+  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
+  return { ok: routed.errors === 0, ...routed };
+}
 function clickUpWebhookExpectedPath(config) {
   try {
     return new URL(config?.webhook?.publicUrl).pathname || "/";
@@ -9870,9 +10058,14 @@ function clickUpWebhookExpectedPath(config) {
 async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date() } = {}) {
   let payload = null;
   let handled = null;
+  let authenticatedWebhook = false;
+  let receivedAt = null;
   const finish = (result) => {
     handled = result;
-    writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state, handled, payload, at: now() });
+    receivedAt ??= now();
+    const auditState = authenticatedWebhook ? { ...state, lastWebhookAt: receivedAt.toISOString() } : state;
+    if (saveState && authenticatedWebhook) saveState(auditState);
+    writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state: auditState, handled, payload, at: receivedAt });
     return result;
   };
   try {
@@ -9886,12 +10079,15 @@ async function handleClickUpWebhookRequest({ method = "POST", url = null, header
     if (bodyBytes > maxBodyBytes) return finish({ ok: false, status: 413, reason: "body_too_large" });
     const signature = headers["x-signature"] || headers["X-Signature"];
     if (!verifyClickUpSignature(rawBody, signature, state?.secret)) return finish({ ok: false, status: 401, reason: "invalid_signature" });
+    authenticatedWebhook = true;
+    receivedAt = now();
     try {
       payload = JSON.parse(Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody));
     } catch {
       return finish({ ok: false, status: 400, reason: "invalid_json" });
     }
-    const result = await routeClickUpWebhookEvent({ payload, config, state, worktree, clickupClient, openCodeClient, saveState });
+    const receivedState = { ...state, lastWebhookAt: receivedAt.toISOString() };
+    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState });
     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() });
@@ -11045,6 +11241,18 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
           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 });
+        try {
+          await reconcileClickUpStartup({
+            config: clickUpWebhookValidation.config,
+            state: activeState,
+            worktree,
+            clickupClient: lifecycleClickUpClient,
+            openCodeClient: input.client,
+            saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, clickUpWebhookValidation.config)
+          });
+        } catch (error) {
+          appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_failed", message: error.message });
+        }
       } else {
         clickUpWebhookLifecycleLog(worktree, { type: "remote_webhook_preserved", reason: readyListener.reason || "listener_unavailable", webhookId: listenerState.webhookId });
         markClickUpWebhookInactive(worktree, listenerState, clickUpWebhookValidation.config);
@@ -11619,7 +11827,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, createClickUpApiClient, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, readClickUpCommentLedger, readClickUpWebhookState, recordClickUpCommentVersionProcessed, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, 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, createClickUpApiClient, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, readClickUpCommentLedger, readClickUpWebhookState, reconcileClickUpStartup, recordClickUpCommentVersionProcessed, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, preEstimateClickUpWork, readMarkdownArtifact, resolveHumanRoles, resolveSafeWorktree, safeWorktreeOrFailure, stripRawLogSections, validateMainWorkspaceBranchSafety, workflowFinalMessageFromPromptResponse };
 export {
   OptimaPlugin as default
 };

package/dist/sanitize_cli.js

@@ -7942,6 +7942,8 @@ var CLICKUP_PM_MENTION_NAME = "Defend Tech Product Manager";
 var CLICKUP_WEBHOOK_RUNTIME_VERSION = 1;
 var CLICKUP_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
+var CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT = 50;
+var CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT = 100;
 var CLICKUP_WEBHOOK_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "info", "verbose"]);
 var CLICKUP_WEBHOOK_REDACTED = "[REDACTED]";
 var DISCUSSION_BACKFILL_FETCH_LIMIT = 100;
@@ -9060,6 +9062,7 @@ function sanitizeClickUpWebhookState(state = {}, config = null) {
     lastValidatedAt: state.lastValidatedAt || null,
     listener: isPlainObject(state.listener) ? state.listener : {},
     pendingSessions: isPlainObject(state.pendingSessions) ? state.pendingSessions : {},
+    lastWebhookAt: state.lastWebhookAt || state.last_webhook_at || null,
     recentEventKeys
   };
 }
@@ -9142,6 +9145,9 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
     async deleteWebhook(webhookId) {
       return request(`https://api.clickup.com/api/v2/webhook/${encodeURIComponent(webhookId)}`, { method: "DELETE" });
     },
+    async getAuthorizedUser() {
+      return request("https://api.clickup.com/api/v2/user");
+    },
     async getTask(taskId) {
       return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}`);
     },
@@ -9156,6 +9162,20 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         method: "POST",
         body: JSON.stringify({ comment_text: comment })
       });
+    },
+    async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
+      const params = new URLSearchParams();
+      if (assigneeId) params.append("assignees[]", assigneeId);
+      for (const status of statuses) if (status) params.append("statuses[]", status);
+      if (limit) params.append("limit", String(limit));
+      return request(`https://api.clickup.com/api/v2/team/${encodeURIComponent(config.teamId)}/task?${params.toString()}`);
+    },
+    async getTaskComments({ taskId, start, limit = CLICKUP_WEBHOOK_STARTUP_COMMENT_LIMIT } = {}) {
+      const params = new URLSearchParams();
+      if (start) params.set("start", String(start));
+      if (limit) params.set("limit", String(limit));
+      const suffix = params.toString() ? `?${params.toString()}` : "";
+      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/comment${suffix}`);
     }
   };
 }
@@ -9385,6 +9405,31 @@ function recordClickUpCommentVersionProcessed({ ledgerPath, key, taskId, eventTy
 function clickUpTaskIdFromPayload(payload = {}) {
   return String(payload.task_id || payload.taskId || payload.task?.id || payload.task?.task_id || "").trim();
 }
+function clickUpTaskListItems(response = {}) {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response.tasks)) return response.tasks;
+  if (Array.isArray(response.data)) return response.data;
+  if (Array.isArray(response?.data?.tasks)) return response.data.tasks;
+  return [];
+}
+function clickUpCommentListItems(response = {}) {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response.comments)) return response.comments;
+  if (Array.isArray(response.data)) return response.data;
+  if (Array.isArray(response?.data?.comments)) return response.data.comments;
+  return [];
+}
+function clickUpTimestampMs(value) {
+  if (value === null || value === void 0 || value === "") return 0;
+  if (value instanceof Date) return value.getTime();
+  const numeric = Number(value);
+  if (Number.isFinite(numeric) && numeric > 0) return numeric < 1e10 ? numeric * 1e3 : numeric;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function clickUpCommentUpdatedMs(comment = {}) {
+  return clickUpTimestampMs(comment.date_updated || comment.dateUpdated || comment.updated_at || comment.updatedAt || comment.date || comment.date_created || comment.created_at);
+}
 function clickUpTaskName(task = {}) {
   return String(task?.name || "").trim();
 }
@@ -9578,6 +9623,45 @@ function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", w
     deliveryEvidencePath ? `Final merge-trackable evidence must be written under ${deliveryEvidencePath}; use .optima only as local mirror/staging.` : null
   ].filter((part) => part !== null).join("\n");
 }
+function clickUpNoAbandonmentRuleText() {
+  return "No-abandonment rule: PM must keep working, or before stopping must post a ClickUp comment, hand off, remove PM as assignee, and assign the next owner.";
+}
+function buildClickUpStartupResumeComment({ taskId, result = {} } = {}) {
+  const contextParts = [
+    result.branch ? `- Branch: ${result.branch}` : null,
+    result.worktree ? `- Worktree: ${result.worktree}` : null,
+    result.deliveryEvidencePath ? `- Delivery evidence path: ${result.deliveryEvidencePath}` : null,
+    result.evidencePath ? `- Local evidence path: ${result.evidencePath}` : null
+  ].filter(Boolean);
+  return [
+    `Startup reconciliation resumed ClickUp task ${taskId}.`,
+    `Route result: ${result.action || "unknown"}${result.ok === false ? " (failed)" : ""}.`,
+    result.sessionId ? `Session id: ${result.sessionId}.` : "Session id: unavailable.",
+    contextParts.length ? contextParts.join("\n") : "Worktree/branch/delivery evidence path: unavailable.",
+    clickUpNoAbandonmentRuleText()
+  ].join("\n");
+}
+function buildClickUpStartupBlockerComment({ taskId, error } = {}) {
+  const summary = error?.message || String(error || "unknown error");
+  return [
+    `Startup reconciliation blocker for ClickUp task ${taskId}: ${summary}`,
+    "Optima skipped this task for this startup pass and continued with the next PM-assigned task.",
+    clickUpNoAbandonmentRuleText()
+  ].join("\n");
+}
+async function postClickUpStartupComment({ clickupClient, worktree, taskId, comment, type } = {}) {
+  if (typeof clickupClient?.postTaskComment !== "function") {
+    appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comment_unavailable", taskId, commentType: type });
+    return { ok: false, skipped: true, reason: "post_task_comment_unavailable" };
+  }
+  try {
+    await clickupClient.postTaskComment({ taskId, comment });
+    return { ok: true };
+  } catch (error) {
+    appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comment_failed", taskId, commentType: type, message: error.message });
+    return { ok: false, error: error.message };
+  }
+}
 function appendClickUpWebhookLocalLog(worktree, entry) {
   const logPath = clickUpWebhookLogPath(worktree);
   fs2.mkdirSync(path2.dirname(logPath), { recursive: true });
@@ -9849,24 +9933,128 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
     stateToPersist = { ...stateToPersist, pendingSessions: remainingPending };
-    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey });
+    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
   }
   const sessionId = String(existingSessionId);
   if (await sessionExists(openCodeClient, sessionId)) {
     if (typeof clickupClient?.updateTaskMetadata === "function") await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: metadataWithRouting });
     await sendSessionEvent(openCodeClient, { sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl });
-    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey });
+    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
   }
   const at = now().toISOString();
   const incidentComment = `Optima webhook could not route this ClickUp event because OpenCode session ${sessionId} is missing on host ${host} at ${at}. No replacement session was created automatically.`;
   appendClickUpWebhookLocalLog(worktree, { type: "missing_session", taskId, sessionId, host, at });
   await clickupClient.postTaskComment({ taskId, comment: incidentComment });
-  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey });
+  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
 }
 async function routeClickUpWebhookEvent(options = {}) {
   const taskId = clickUpTaskIdFromPayload(options.payload || {});
   return withClickUpTaskRouteLock(taskId, () => routeClickUpWebhookEventUnlocked(options));
 }
+async function reconcileClickUpStartup({ config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, saveState = null, now = () => /* @__PURE__ */ new Date(), limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
+  if (!config || !clickupClient?.listAssignedTasks) return { ok: true, skipped: true, reason: "clickup_task_listing_unavailable", assigned: 0, comments: 0 };
+  let authorizedUserId = "";
+  if (clickupClient?.getAuthorizedUser) {
+    try {
+      const userResponse = await clickupClient.getAuthorizedUser();
+      authorizedUserId = String(userResponse?.user?.id || userResponse?.id || "").trim();
+    } catch (error) {
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_user_lookup_failed", message: error.message });
+    }
+  }
+  let mutableState = state;
+  const persistState = (nextState) => {
+    mutableState = nextState;
+    if (saveState) saveState(nextState);
+  };
+  const lastWebhookMs = clickUpTimestampMs(mutableState.lastWebhookAt);
+  const ignored = new Set((config.routing?.ignoredStatuses || CLICKUP_WEBHOOK_TERMINAL_STATUSES).map(normalizeClickUpStatus));
+  const routed = { assigned: 0, comments: 0, ignored: 0, errors: 0 };
+  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_started", lastWebhookAt: state.lastWebhookAt || null });
+  const listed = await clickupClient.listAssignedTasks({ assigneeId: config.routing.productManagerAssigneeId, limit });
+  const tasks = clickUpTaskListItems(listed).slice(0, limit);
+  for (const task of tasks) {
+    const taskId = String(task?.id || task?.task_id || task?.taskId || "").trim();
+    if (!taskId) {
+      routed.ignored += 1;
+      continue;
+    }
+    if (ignored.has(normalizeClickUpStatus(clickUpTaskStatus(task)))) {
+      routed.ignored += 1;
+      continue;
+    }
+    if (!isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId)) {
+      routed.ignored += 1;
+      continue;
+    }
+    try {
+      const result = await routeClickUpWebhookEvent({
+        payload: { webhook_id: mutableState.webhookId || "startup", event: "taskAssigneeUpdated", task_id: taskId, task, startup_reconciliation: true },
+        config,
+        state: mutableState,
+        worktree,
+        clickupClient,
+        openCodeClient,
+        sessionExists,
+        createSession,
+        sendSessionEvent,
+        saveState: persistState,
+        now
+      });
+      if (result?.ok && result.action !== "ignored") {
+        routed.assigned += 1;
+        await postClickUpStartupComment({
+          clickupClient,
+          worktree,
+          taskId,
+          type: "resume",
+          comment: buildClickUpStartupResumeComment({ taskId, result })
+        });
+      }
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_failed", taskId, message: error.message });
+      await postClickUpStartupComment({
+        clickupClient,
+        worktree,
+        taskId,
+        type: "blocker",
+        comment: buildClickUpStartupBlockerComment({ taskId, error })
+      });
+    }
+    if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
+    try {
+      const commentsResponse = await clickupClient.getTaskComments({ taskId, start: lastWebhookMs, 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;
+        const authorId = clickUpCommentAuthorId(comment);
+        if (authorId && (authorId === config.routing.ignoredCommentAuthorId || authorId === authorizedUserId)) continue;
+        if (!clickUpCommentMentionsProductManager(comment, config.routing)) continue;
+        const event = comment.date_updated || comment.dateUpdated || comment.updated_at || comment.updatedAt ? "taskCommentUpdated" : "taskCommentPosted";
+        const result = await routeClickUpWebhookEvent({
+          payload: { webhook_id: mutableState.webhookId || "startup", event, task_id: taskId, task, comment, history_item: { id: `startup-${taskId}-${comment.id || commentMs}` }, startup_reconciliation: true },
+          config,
+          state: mutableState,
+          worktree,
+          clickupClient,
+          openCodeClient,
+          sessionExists,
+          createSession,
+          sendSessionEvent,
+          saveState: persistState,
+          now
+        });
+        if (result?.ok && result.action !== "ignored") routed.comments += 1;
+      }
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comments_failed", taskId, message: error.message });
+    }
+  }
+  clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
+  return { ok: routed.errors === 0, ...routed };
+}
 function clickUpWebhookExpectedPath(config) {
   try {
     return new URL(config?.webhook?.publicUrl).pathname || "/";
@@ -9877,9 +10065,14 @@ function clickUpWebhookExpectedPath(config) {
 async function handleClickUpWebhookRequest({ method = "POST", url = null, headers = {}, rawBody = "", config, state, worktree, clickupClient, openCodeClient, saveState, now = () => /* @__PURE__ */ new Date() } = {}) {
   let payload = null;
   let handled = null;
+  let authenticatedWebhook = false;
+  let receivedAt = null;
   const finish = (result) => {
     handled = result;
-    writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state, handled, payload, at: now() });
+    receivedAt ??= now();
+    const auditState = authenticatedWebhook ? { ...state, lastWebhookAt: receivedAt.toISOString() } : state;
+    if (saveState && authenticatedWebhook) saveState(auditState);
+    writeClickUpWebhookAuditLog({ method, url, headers, rawBody, config, state: auditState, handled, payload, at: receivedAt });
     return result;
   };
   try {
@@ -9893,12 +10086,15 @@ async function handleClickUpWebhookRequest({ method = "POST", url = null, header
     if (bodyBytes > maxBodyBytes) return finish({ ok: false, status: 413, reason: "body_too_large" });
     const signature = headers["x-signature"] || headers["X-Signature"];
     if (!verifyClickUpSignature(rawBody, signature, state?.secret)) return finish({ ok: false, status: 401, reason: "invalid_signature" });
+    authenticatedWebhook = true;
+    receivedAt = now();
     try {
       payload = JSON.parse(Buffer.isBuffer(rawBody) ? rawBody.toString("utf8") : String(rawBody));
     } catch {
       return finish({ ok: false, status: 400, reason: "invalid_json" });
     }
-    const result = await routeClickUpWebhookEvent({ payload, config, state, worktree, clickupClient, openCodeClient, saveState });
+    const receivedState = { ...state, lastWebhookAt: receivedAt.toISOString() };
+    const result = await routeClickUpWebhookEvent({ payload, config, state: receivedState, worktree, clickupClient, openCodeClient, saveState });
     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() });
@@ -11052,6 +11248,18 @@ async function OptimaPlugin(input = {}, pluginOptions = {}) {
           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 });
+        try {
+          await reconcileClickUpStartup({
+            config: clickUpWebhookValidation.config,
+            state: activeState,
+            worktree,
+            clickupClient: lifecycleClickUpClient,
+            openCodeClient: input.client,
+            saveState: (nextState) => writeClickUpWebhookState(worktree, nextState, clickUpWebhookValidation.config)
+          });
+        } catch (error) {
+          appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_failed", message: error.message });
+        }
       } else {
         clickUpWebhookLifecycleLog(worktree, { type: "remote_webhook_preserved", reason: readyListener.reason || "listener_unavailable", webhookId: listenerState.webhookId });
         markClickUpWebhookInactive(worktree, listenerState, clickUpWebhookValidation.config);
@@ -11626,7 +11834,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, createClickUpApiClient, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, readClickUpCommentLedger, readClickUpWebhookState, recordClickUpCommentVersionProcessed, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, 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, createClickUpApiClient, deliveryEvidencePathForClickUpTask, ensureClickUpTaskWorktree, ensureClickUpWebhookSubscription, handleClickUpWebhookRequest, isClickUpWebhookStateActive, normalizeClickUpWebhookConfig, normalizeClickUpWebhookLogLevel, normalizeOpenCodeBaseUrl, readClickUpCommentLedger, readClickUpWebhookState, reconcileClickUpStartup, recordClickUpCommentVersionProcessed, resolveOptimaPluginOptions, resolveSecretReference, routeClickUpWebhookEvent, sendOpenCodeSessionEvent, sendOpenCodeSessionEventDirect, stableClickUpCommentVersionMarker, startClickUpWebhookListener, validateClickUpWebhookState, verifyClickUpSignature, writeClickUpWebhookState, decideClickUpStatusAction, deriveClickUpBranchName, deriveClickUpPendingSubtaskBranch, deriveClickUpPrTarget, deriveClickUpWorktree, determineClickUpMergeAuthority, ensureOptimaGitignoreRules, explicitSafeInputWorktree, finalApprovalAssignees, formatValidationResult, isIgnoredClickUpTaskType, isOptimaPluginPackageWorktree, isSafeWritableDirectory, loadHumansRegistry, mergeClickUpAgentMetadata, mergeClickUpSessionMetadata, migrateLegacyOptimaLayout, normalizeAgentMetadataJson, normalizeClickUpStatus, normalizeClickUpTaskType, normalizePromptResponseParts, normalizeWorkflowTaskPath, parseClickUpSubtasksMarkdown, parseHumansRegistry, parseMarkdownArtifact, parseMarkdownSections, 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.35",
+  "version": "0.1.37",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/defend-tech/opencode-optima.git"