@defend-tech/opencode-optima 0.1.34 → 0.1.36

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}`);
     }
   };
 }
@@ -9194,7 +9214,7 @@ async function findReusableClickUpWebhook(config, clickupClient = null) {
   }
   return null;
 }
-async function validateClickUpWebhookState(state, config, clickupClient = null) {
+async function validateClickUpWebhookState(state, config, clickupClient = null, { allowRemoteUnhealthyLocalRecovery = false } = {}) {
   if (!isClickUpWebhookStateActive(state, config)) return { valid: false, reason: "state_incomplete" };
   if (clickupClient?.listWebhooks) {
     const listed = await clickupClient.listWebhooks({ teamId: config.teamId });
@@ -9202,10 +9222,22 @@ async function validateClickUpWebhookState(state, config, clickupClient = null)
     if (!match) return { valid: false, reason: "remote_state_missing" };
     const remote = normalizeClickUpWebhookApiResponse(match, config);
     const remoteWithLocalSecret = { ...remote, secret: state.secret };
-    if (!isClickUpWebhookStateActive(remoteWithLocalSecret, config) || remote.webhookId !== state.webhookId) {
-      return { valid: false, reason: "remote_state_mismatch", remote };
+    if (isClickUpWebhookStateActive(remoteWithLocalSecret, config) && remote.webhookId === state.webhookId) {
+      return { valid: true, mode: "remote", state: { ...remoteWithLocalSecret, recentEventKeys: state.recentEventKeys || [], lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+    }
+    const localStateValidation = await validateClickUpWebhookState(state, config, null);
+    if (allowRemoteUnhealthyLocalRecovery && localStateValidation.valid && remote.webhookId === state.webhookId) {
+      const remoteConfigMatches = remote.publicUrl === config.webhook.publicUrl && [...new Set(config.webhook.events || [])].every((event) => new Set(remote.events || []).has(event));
+      if (remoteConfigMatches) {
+        return {
+          ...localStateValidation,
+          mode: "local_state_remote_unhealthy",
+          limitation: "ClickUp remote webhook is present but unhealthy; Optima starts the local listener from matching local id/secret/config so delivery can recover.",
+          remote
+        };
+      }
     }
-    return { valid: true, mode: "remote", state: { ...remoteWithLocalSecret, recentEventKeys: state.recentEventKeys || [], lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+    return { valid: false, reason: "remote_state_mismatch", remote };
   }
   return { valid: true, mode: "local_state", state: { ...state, lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() }, limitation: "ClickUp API validation unavailable; Optima trusts ignored local runtime state only after id/secret/config checks." };
 }
@@ -9215,7 +9247,7 @@ async function ensureClickUpWebhookSubscription({ validation, worktree, clickupC
   }
   const { config } = validation;
   const existing = readClickUpWebhookState(worktree, config);
-  const existingValidation = await validateClickUpWebhookState(existing, config, clickupClient);
+  const existingValidation = await validateClickUpWebhookState(existing, config, clickupClient, { allowRemoteUnhealthyLocalRecovery: true });
   if (existingValidation.valid) {
     const state = writeClickUpWebhookState(worktree, { ...existingValidation.state, recentEventKeys: existing.recentEventKeys || [] }, config);
     clickUpWebhookLifecycleLog(worktree, { type: "remote_webhook_reused", webhookId: state.webhookId, mode: existingValidation.mode });
@@ -9366,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();
 }
@@ -9758,12 +9815,18 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   if (!taskId) return { ok: false, action: "error", reason: "missing_task_id" };
   let task = payload.task || (clickupClient?.getTask ? await clickupClient.getTask(taskId) : null);
   if (!task) return { ok: false, action: "error", reason: "task_unavailable", taskId };
+  if (clickupClient?.getTask) {
+    const latestTask = await clickupClient.getTask(taskId);
+    if (latestTask) task = latestTask;
+  }
   const isCommentEvent = eventType === "taskCommentPosted" || eventType === "taskCommentUpdated";
   if (isCommentEvent) {
     const comment = clickUpCommentFromPayload(payload);
     const authorId = clickUpCommentAuthorId(comment);
     if (authorId && authorId === config.routing.ignoredCommentAuthorId) return finish({ ok: true, action: "ignored", reason: "self_authored_comment", taskId });
-    if (!clickUpCommentMentionsProductManager(comment, config.routing)) return finish({ ok: true, action: "ignored", reason: "missing_product_manager_mention", taskId });
+    const mentionsProductManager = clickUpCommentMentionsProductManager(comment, config.routing);
+    const assignedToProductManager = isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId);
+    if (!mentionsProductManager && !assignedToProductManager) return finish({ ok: true, action: "ignored", reason: "missing_product_manager_mention_or_assignment", taskId });
     commentLedgerKey = clickUpCommentLedgerKey({ taskId, eventType, payload });
     try {
       if (isClickUpCommentVersionProcessed({ ledgerPath: commentLedgerPath, key: commentLedgerKey, worktree })) {
@@ -9775,10 +9838,6 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   }
   if (!isCommentEvent && !isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId)) return finish({ ok: true, action: "ignored", reason: "not_assigned_to_product_manager", taskId });
   if (isClickUpTaskTerminal(task, payload, config.routing.ignoredStatuses)) return finish({ ok: true, action: "ignored", reason: "terminal_status", taskId });
-  if (clickupClient?.getTask) {
-    const latestTask = await clickupClient.getTask(taskId);
-    if (latestTask) task = latestTask;
-  }
   const sessionTitle = formatClickUpSessionTitle({ taskId, payloadTask: payload.task, task });
   const existingMetadata = clickUpTaskAgentMetadata(task, config.routing.metadataFieldId);
   const metadata = normalizeAgentMetadataJson(existingMetadata);
@@ -9846,6 +9905,94 @@ 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;
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_failed", taskId, message: error.message });
+    }
+    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 || "/";
@@ -9856,9 +10003,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 {
@@ -9872,12 +10024,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() });
@@ -11031,6 +11186,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);
@@ -11605,7 +11772,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}`);
     }
   };
 }
@@ -9201,7 +9221,7 @@ async function findReusableClickUpWebhook(config, clickupClient = null) {
   }
   return null;
 }
-async function validateClickUpWebhookState(state, config, clickupClient = null) {
+async function validateClickUpWebhookState(state, config, clickupClient = null, { allowRemoteUnhealthyLocalRecovery = false } = {}) {
   if (!isClickUpWebhookStateActive(state, config)) return { valid: false, reason: "state_incomplete" };
   if (clickupClient?.listWebhooks) {
     const listed = await clickupClient.listWebhooks({ teamId: config.teamId });
@@ -9209,10 +9229,22 @@ async function validateClickUpWebhookState(state, config, clickupClient = null)
     if (!match) return { valid: false, reason: "remote_state_missing" };
     const remote = normalizeClickUpWebhookApiResponse(match, config);
     const remoteWithLocalSecret = { ...remote, secret: state.secret };
-    if (!isClickUpWebhookStateActive(remoteWithLocalSecret, config) || remote.webhookId !== state.webhookId) {
-      return { valid: false, reason: "remote_state_mismatch", remote };
+    if (isClickUpWebhookStateActive(remoteWithLocalSecret, config) && remote.webhookId === state.webhookId) {
+      return { valid: true, mode: "remote", state: { ...remoteWithLocalSecret, recentEventKeys: state.recentEventKeys || [], lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+    }
+    const localStateValidation = await validateClickUpWebhookState(state, config, null);
+    if (allowRemoteUnhealthyLocalRecovery && localStateValidation.valid && remote.webhookId === state.webhookId) {
+      const remoteConfigMatches = remote.publicUrl === config.webhook.publicUrl && [...new Set(config.webhook.events || [])].every((event) => new Set(remote.events || []).has(event));
+      if (remoteConfigMatches) {
+        return {
+          ...localStateValidation,
+          mode: "local_state_remote_unhealthy",
+          limitation: "ClickUp remote webhook is present but unhealthy; Optima starts the local listener from matching local id/secret/config so delivery can recover.",
+          remote
+        };
+      }
     }
-    return { valid: true, mode: "remote", state: { ...remoteWithLocalSecret, recentEventKeys: state.recentEventKeys || [], lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() } };
+    return { valid: false, reason: "remote_state_mismatch", remote };
   }
   return { valid: true, mode: "local_state", state: { ...state, lastValidatedAt: (/* @__PURE__ */ new Date()).toISOString() }, limitation: "ClickUp API validation unavailable; Optima trusts ignored local runtime state only after id/secret/config checks." };
 }
@@ -9222,7 +9254,7 @@ async function ensureClickUpWebhookSubscription({ validation, worktree, clickupC
   }
   const { config } = validation;
   const existing = readClickUpWebhookState(worktree, config);
-  const existingValidation = await validateClickUpWebhookState(existing, config, clickupClient);
+  const existingValidation = await validateClickUpWebhookState(existing, config, clickupClient, { allowRemoteUnhealthyLocalRecovery: true });
   if (existingValidation.valid) {
     const state = writeClickUpWebhookState(worktree, { ...existingValidation.state, recentEventKeys: existing.recentEventKeys || [] }, config);
     clickUpWebhookLifecycleLog(worktree, { type: "remote_webhook_reused", webhookId: state.webhookId, mode: existingValidation.mode });
@@ -9373,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();
 }
@@ -9765,12 +9822,18 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   if (!taskId) return { ok: false, action: "error", reason: "missing_task_id" };
   let task = payload.task || (clickupClient?.getTask ? await clickupClient.getTask(taskId) : null);
   if (!task) return { ok: false, action: "error", reason: "task_unavailable", taskId };
+  if (clickupClient?.getTask) {
+    const latestTask = await clickupClient.getTask(taskId);
+    if (latestTask) task = latestTask;
+  }
   const isCommentEvent = eventType === "taskCommentPosted" || eventType === "taskCommentUpdated";
   if (isCommentEvent) {
     const comment = clickUpCommentFromPayload(payload);
     const authorId = clickUpCommentAuthorId(comment);
     if (authorId && authorId === config.routing.ignoredCommentAuthorId) return finish({ ok: true, action: "ignored", reason: "self_authored_comment", taskId });
-    if (!clickUpCommentMentionsProductManager(comment, config.routing)) return finish({ ok: true, action: "ignored", reason: "missing_product_manager_mention", taskId });
+    const mentionsProductManager = clickUpCommentMentionsProductManager(comment, config.routing);
+    const assignedToProductManager = isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId);
+    if (!mentionsProductManager && !assignedToProductManager) return finish({ ok: true, action: "ignored", reason: "missing_product_manager_mention_or_assignment", taskId });
     commentLedgerKey = clickUpCommentLedgerKey({ taskId, eventType, payload });
     try {
       if (isClickUpCommentVersionProcessed({ ledgerPath: commentLedgerPath, key: commentLedgerKey, worktree })) {
@@ -9782,10 +9845,6 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   }
   if (!isCommentEvent && !isClickUpTaskAssignedToProductManager(task, config.routing.productManagerAssigneeId)) return finish({ ok: true, action: "ignored", reason: "not_assigned_to_product_manager", taskId });
   if (isClickUpTaskTerminal(task, payload, config.routing.ignoredStatuses)) return finish({ ok: true, action: "ignored", reason: "terminal_status", taskId });
-  if (clickupClient?.getTask) {
-    const latestTask = await clickupClient.getTask(taskId);
-    if (latestTask) task = latestTask;
-  }
   const sessionTitle = formatClickUpSessionTitle({ taskId, payloadTask: payload.task, task });
   const existingMetadata = clickUpTaskAgentMetadata(task, config.routing.metadataFieldId);
   const metadata = normalizeAgentMetadataJson(existingMetadata);
@@ -9853,6 +9912,94 @@ 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;
+    } catch (error) {
+      routed.errors += 1;
+      appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_task_failed", taskId, message: error.message });
+    }
+    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 || "/";
@@ -9863,9 +10010,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 {
@@ -9879,12 +10031,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() });
@@ -11038,6 +11193,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);
@@ -11612,7 +11779,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.34",
+  "version": "0.1.36",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/defend-tech/opencode-optima.git"