@defend-tech/opencode-optima 0.1.37 → 0.1.39

package/dist/index.js

@@ -7932,6 +7932,7 @@ var CLICKUP_WEBHOOK_EVENTS = ["taskStatusUpdated", "taskAssigneeUpdated", "taskC
 var CLICKUP_WEBHOOK_TERMINAL_STATUSES = ["backlog", "done", "completed", "closed"];
 var CLICKUP_PM_METADATA_KEY = "optima.sessions.product_manager";
 var CLICKUP_PM_MENTION_NAME = "Defend Tech Product Manager";
+var CLICKUP_BLOCKER_TAG_NAME = "BLOCKER";
 var CLICKUP_WEBHOOK_RUNTIME_VERSION = 1;
 var CLICKUP_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
@@ -9156,6 +9157,12 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         body: JSON.stringify({ comment_text: comment })
       });
     },
+    async addTaskTag({ taskId, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
+      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/tag/${encodeURIComponent(tagName)}`, {
+        method: "POST",
+        body: JSON.stringify({})
+      });
+    },
     async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
       const params = new URLSearchParams();
       if (assigneeId) params.append("assignees[]", assigneeId);
@@ -9600,6 +9607,88 @@ async function sendOpenCodeSessionEvent(client, { sessionId, agent, text, direct
   if (directBaseUrl) return sendOpenCodeSessionEventDirect({ baseUrl: directBaseUrl, sessionId, text, fetchImpl });
   throw new Error("OpenCode client does not expose session.prompt or session.promptAsync.");
 }
+function normalizeOpenCodeSessionMessages(result) {
+  const data = result?.data ?? result;
+  if (Array.isArray(data)) return [...data];
+  if (Array.isArray(data?.messages)) return [...data.messages];
+  if (Array.isArray(data?.items)) return [...data.items];
+  return [];
+}
+async function readOpenCodeSessionMessages(client, { sessionId, limit = 20 } = {}) {
+  if (typeof client?.session?.messages !== "function") return null;
+  const attempts = [
+    { path: { id: sessionId }, query: { limit } },
+    { path: { sessionID: sessionId }, query: { limit } },
+    { id: sessionId, limit },
+    { sessionID: sessionId, limit }
+  ];
+  let firstError = null;
+  for (const attempt of attempts) {
+    try {
+      return normalizeOpenCodeSessionMessages(await client.session.messages(attempt));
+    } catch (error) {
+      firstError ??= error;
+    }
+  }
+  throw firstError;
+}
+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 : [];
+  for (const part of partList) parts.push(part?.text, part?.content);
+  return parts.filter((value) => typeof value === "string").join("\n");
+}
+async function verifyOpenCodeSessionEventDelivery(client, { sessionId, beforeMessages = null, expectedText = "", markers = [], attempts = 3, delayMs = 25 } = {}) {
+  let lastError = "message_verification_unavailable";
+  for (let attempt = 0; attempt < Math.max(1, attempts); attempt += 1) {
+    try {
+      const afterMessages = await readOpenCodeSessionMessages(client, { sessionId, limit: 50 });
+      if (!afterMessages) return { ok: true, method: "verification_unavailable", skipped: true };
+      const beforeCount = Array.isArray(beforeMessages) ? beforeMessages.length : null;
+      if (beforeCount !== null && afterMessages.length > beforeCount) return { ok: true, method: "message_count", beforeCount, afterCount: afterMessages.length };
+      const textNeedles = [expectedText, ...markers].map((value) => String(value || "").trim()).filter(Boolean);
+      const haystack = afterMessages.slice(-20).map(openCodeMessageText).join("\n");
+      const matched = textNeedles.find((needle) => haystack.includes(needle));
+      if (matched) return { ok: true, method: "message_text", marker: matched, beforeCount, afterCount: afterMessages.length };
+      lastError = "message_not_visible";
+    } catch (error) {
+      lastError = error.message || "message_verification_failed";
+    }
+    if (attempt < attempts - 1 && delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  return { ok: false, reason: lastError };
+}
+async function applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
+  if (typeof clickupClient?.addTaskTag !== "function") {
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_unavailable", taskId, reason, source, tagName });
+    return { ok: false, skipped: true, reason: "add_task_tag_unavailable", tagName };
+  }
+  try {
+    await clickupClient.addTaskTag({ taskId, tagName });
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_applied", taskId, reason, source, tagName });
+    return { ok: true, tagName };
+  } catch (error) {
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_failed", taskId, reason, source, tagName, message: error.message });
+    return { ok: false, error: error.message, tagName };
+  }
+}
+async function deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent, text, directory, opencodeBaseUrl, eventMarkers = [], verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery } = {}) {
+  const beforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, limit: 50 }).catch(() => null);
+  await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl });
+  let verification = await verifySessionEventDelivery(openCodeClient, { sessionId, beforeMessages, expectedText: text, markers: eventMarkers });
+  if (verification?.ok) return { ok: true, verification, fallback: false };
+  const canFallbackDirect = Boolean(opencodeBaseUrl);
+  if (canFallbackDirect) {
+    const retryBeforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, limit: 50 }).catch(() => beforeMessages);
+    await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: true });
+    verification = await verifySessionEventDelivery(openCodeClient, { sessionId, beforeMessages: retryBeforeMessages, expectedText: text, markers: eventMarkers });
+    if (verification?.ok) return { ok: true, verification, fallback: true };
+  }
+  const reason = verification?.reason || "message_delivery_failed";
+  appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason, fallbackAttempted: canFallbackDirect });
+  const blocker = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source: canFallbackDirect ? "delivery_fallback_failed" : "delivery_verification_failed" });
+  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: canFallbackDirect, blockerTag: blocker };
+}
 function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", worktree = "", deliveryEvidencePath = "" }) {
   const comment = clickUpCommentFromPayload(payload);
   const commentText = clickUpCommentText(comment).trim();
@@ -9616,45 +9705,6 @@ 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 });
@@ -9831,7 +9881,7 @@ async function withClickUpTaskRouteLock(taskId, operation) {
     if (activeClickUpTaskRoutes.get(key) === current) activeClickUpTaskRoutes.delete(key);
   }
 }
-async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktree, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
+async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktree, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
   const eventType = clickUpEventType(payload);
   const eventKey = clickUpWebhookEventKey(payload);
   const remembered = rememberClickUpWebhookEvent(state, eventKey);
@@ -9890,8 +9940,8 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   } catch (error) {
     const message = `Optima webhook could not create or reuse a task worktree for ${taskId}: ${error.message}`;
     appendClickUpWebhookLocalLog(worktree, { type: "task_worktree_failed", taskId, message });
-    if (typeof clickupClient?.postTaskComment === "function") await clickupClient.postTaskComment({ taskId, comment: message });
-    return { ok: false, action: "error", reason: "task_worktree_failed", taskId, message };
+    const blockerTag2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "task_worktree_failed", source: "route_worktree" });
+    return { ok: false, action: "error", reason: "task_worktree_failed", taskId, message, blockerTag: blockerTag2 };
   }
   const deliveryEvidencePath = deliveryEvidencePathForClickUpTask(taskId);
   const routingMetadata = {
@@ -9921,24 +9971,25 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
       appendClickUpWebhookLocalLog(worktree, { type: "pending_session_metadata_failed", taskId, sessionId: pendingSessionId, message: error.message });
       throw error;
     }
-    await sendSessionEvent(openCodeClient, { sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl });
+    const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
+    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
     const nextMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(pendingMetadata, config.routing.metadataKey, pendingSessionId), config.routing.metadataKey);
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
     stateToPersist = { ...stateToPersist, pendingSessions: remainingPending };
-    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryFallback: delivery.fallback });
   }
   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, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
+    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryFallback: delivery.fallback });
   }
   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, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+  const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "missing_session", source: "route_existing_session" });
+  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag });
 }
 async function routeClickUpWebhookEvent(options = {}) {
   const taskId = clickUpTaskIdFromPayload(options.payload || {});
@@ -9996,24 +10047,14 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       });
       if (result?.ok && result.action !== "ignored") {
         routed.assigned += 1;
-        await postClickUpStartupComment({
-          clickupClient,
-          worktree,
-          taskId,
-          type: "resume",
-          comment: buildClickUpStartupResumeComment({ taskId, result })
-        });
+      } else if (result?.ok === false) {
+        routed.errors += 1;
+        if (!result.blockerTag) await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
       }
     } 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 })
-      });
+      await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_task_failed", source: "startup_reconciliation_task" });
     }
     if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
     try {
@@ -10043,6 +10084,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     } catch (error) {
       routed.errors += 1;
       appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comments_failed", taskId, message: error.message });
+      await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_comments_failed", source: "startup_reconciliation_comments" });
     }
   }
   clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
@@ -11827,7 +11869,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, 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 };
+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, verifyOpenCodeSessionEventDelivery, 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

@@ -7939,6 +7939,7 @@ var CLICKUP_WEBHOOK_EVENTS = ["taskStatusUpdated", "taskAssigneeUpdated", "taskC
 var CLICKUP_WEBHOOK_TERMINAL_STATUSES = ["backlog", "done", "completed", "closed"];
 var CLICKUP_PM_METADATA_KEY = "optima.sessions.product_manager";
 var CLICKUP_PM_MENTION_NAME = "Defend Tech Product Manager";
+var CLICKUP_BLOCKER_TAG_NAME = "BLOCKER";
 var CLICKUP_WEBHOOK_RUNTIME_VERSION = 1;
 var CLICKUP_WEBHOOK_MAX_BODY_BYTES = 1024 * 1024;
 var CLICKUP_WEBHOOK_REQUEST_TIMEOUT_MS = 1e4;
@@ -9163,6 +9164,12 @@ function createClickUpApiClient(config, fetchImpl = globalThis.fetch) {
         body: JSON.stringify({ comment_text: comment })
       });
     },
+    async addTaskTag({ taskId, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
+      return request(`https://api.clickup.com/api/v2/task/${encodeURIComponent(taskId)}/tag/${encodeURIComponent(tagName)}`, {
+        method: "POST",
+        body: JSON.stringify({})
+      });
+    },
     async listAssignedTasks({ assigneeId, statuses = [], limit = CLICKUP_WEBHOOK_STARTUP_TASK_LIMIT } = {}) {
       const params = new URLSearchParams();
       if (assigneeId) params.append("assignees[]", assigneeId);
@@ -9607,6 +9614,88 @@ async function sendOpenCodeSessionEvent(client, { sessionId, agent, text, direct
   if (directBaseUrl) return sendOpenCodeSessionEventDirect({ baseUrl: directBaseUrl, sessionId, text, fetchImpl });
   throw new Error("OpenCode client does not expose session.prompt or session.promptAsync.");
 }
+function normalizeOpenCodeSessionMessages(result) {
+  const data = result?.data ?? result;
+  if (Array.isArray(data)) return [...data];
+  if (Array.isArray(data?.messages)) return [...data.messages];
+  if (Array.isArray(data?.items)) return [...data.items];
+  return [];
+}
+async function readOpenCodeSessionMessages(client, { sessionId, limit = 20 } = {}) {
+  if (typeof client?.session?.messages !== "function") return null;
+  const attempts = [
+    { path: { id: sessionId }, query: { limit } },
+    { path: { sessionID: sessionId }, query: { limit } },
+    { id: sessionId, limit },
+    { sessionID: sessionId, limit }
+  ];
+  let firstError = null;
+  for (const attempt of attempts) {
+    try {
+      return normalizeOpenCodeSessionMessages(await client.session.messages(attempt));
+    } catch (error) {
+      firstError ??= error;
+    }
+  }
+  throw firstError;
+}
+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 : [];
+  for (const part of partList) parts.push(part?.text, part?.content);
+  return parts.filter((value) => typeof value === "string").join("\n");
+}
+async function verifyOpenCodeSessionEventDelivery(client, { sessionId, beforeMessages = null, expectedText = "", markers = [], attempts = 3, delayMs = 25 } = {}) {
+  let lastError = "message_verification_unavailable";
+  for (let attempt = 0; attempt < Math.max(1, attempts); attempt += 1) {
+    try {
+      const afterMessages = await readOpenCodeSessionMessages(client, { sessionId, limit: 50 });
+      if (!afterMessages) return { ok: true, method: "verification_unavailable", skipped: true };
+      const beforeCount = Array.isArray(beforeMessages) ? beforeMessages.length : null;
+      if (beforeCount !== null && afterMessages.length > beforeCount) return { ok: true, method: "message_count", beforeCount, afterCount: afterMessages.length };
+      const textNeedles = [expectedText, ...markers].map((value) => String(value || "").trim()).filter(Boolean);
+      const haystack = afterMessages.slice(-20).map(openCodeMessageText).join("\n");
+      const matched = textNeedles.find((needle) => haystack.includes(needle));
+      if (matched) return { ok: true, method: "message_text", marker: matched, beforeCount, afterCount: afterMessages.length };
+      lastError = "message_not_visible";
+    } catch (error) {
+      lastError = error.message || "message_verification_failed";
+    }
+    if (attempt < attempts - 1 && delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+  return { ok: false, reason: lastError };
+}
+async function applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source, tagName = CLICKUP_BLOCKER_TAG_NAME } = {}) {
+  if (typeof clickupClient?.addTaskTag !== "function") {
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_unavailable", taskId, reason, source, tagName });
+    return { ok: false, skipped: true, reason: "add_task_tag_unavailable", tagName };
+  }
+  try {
+    await clickupClient.addTaskTag({ taskId, tagName });
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_applied", taskId, reason, source, tagName });
+    return { ok: true, tagName };
+  } catch (error) {
+    appendClickUpWebhookLocalLog(worktree, { type: "blocker_tag_failed", taskId, reason, source, tagName, message: error.message });
+    return { ok: false, error: error.message, tagName };
+  }
+}
+async function deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent, text, directory, opencodeBaseUrl, eventMarkers = [], verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery } = {}) {
+  const beforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, limit: 50 }).catch(() => null);
+  await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl });
+  let verification = await verifySessionEventDelivery(openCodeClient, { sessionId, beforeMessages, expectedText: text, markers: eventMarkers });
+  if (verification?.ok) return { ok: true, verification, fallback: false };
+  const canFallbackDirect = Boolean(opencodeBaseUrl);
+  if (canFallbackDirect) {
+    const retryBeforeMessages = await readOpenCodeSessionMessages(openCodeClient, { sessionId, limit: 50 }).catch(() => beforeMessages);
+    await sendSessionEvent(openCodeClient, { sessionId, agent, text, directory, opencodeBaseUrl, direct: true });
+    verification = await verifySessionEventDelivery(openCodeClient, { sessionId, beforeMessages: retryBeforeMessages, expectedText: text, markers: eventMarkers });
+    if (verification?.ok) return { ok: true, verification, fallback: true };
+  }
+  const reason = verification?.reason || "message_delivery_failed";
+  appendClickUpWebhookLocalLog(worktree, { type: "message_delivery_failed", taskId, sessionId, reason, fallbackAttempted: canFallbackDirect });
+  const blocker = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason, source: canFallbackDirect ? "delivery_fallback_failed" : "delivery_verification_failed" });
+  return { ok: false, action: "message_delivery_failed", reason, taskId, sessionId, fallbackAttempted: canFallbackDirect, blockerTag: blocker };
+}
 function formatClickUpWebhookPrompt({ eventType, taskId, payload, branch = "", worktree = "", deliveryEvidencePath = "" }) {
   const comment = clickUpCommentFromPayload(payload);
   const commentText = clickUpCommentText(comment).trim();
@@ -9623,45 +9712,6 @@ 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 });
@@ -9838,7 +9888,7 @@ async function withClickUpTaskRouteLock(taskId, operation) {
     if (activeClickUpTaskRoutes.get(key) === current) activeClickUpTaskRoutes.delete(key);
   }
 }
-async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktree, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
+async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, worktree = process.cwd(), clickupClient, openCodeClient, sessionExists = openCodeSessionExists, createSession = createOpenCodeSession, sendSessionEvent = sendOpenCodeSessionEvent, ensureTaskWorktree = ensureClickUpTaskWorktree, verifySessionEventDelivery = verifyOpenCodeSessionEventDelivery, saveState = null, now = () => /* @__PURE__ */ new Date(), host = os.hostname(), commentLedgerPath = clickUpCommentLedgerPath(worktree) } = {}) {
   const eventType = clickUpEventType(payload);
   const eventKey = clickUpWebhookEventKey(payload);
   const remembered = rememberClickUpWebhookEvent(state, eventKey);
@@ -9897,8 +9947,8 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
   } catch (error) {
     const message = `Optima webhook could not create or reuse a task worktree for ${taskId}: ${error.message}`;
     appendClickUpWebhookLocalLog(worktree, { type: "task_worktree_failed", taskId, message });
-    if (typeof clickupClient?.postTaskComment === "function") await clickupClient.postTaskComment({ taskId, comment: message });
-    return { ok: false, action: "error", reason: "task_worktree_failed", taskId, message };
+    const blockerTag2 = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "task_worktree_failed", source: "route_worktree" });
+    return { ok: false, action: "error", reason: "task_worktree_failed", taskId, message, blockerTag: blockerTag2 };
   }
   const deliveryEvidencePath = deliveryEvidencePathForClickUpTask(taskId);
   const routingMetadata = {
@@ -9928,24 +9978,25 @@ async function routeClickUpWebhookEventUnlocked({ payload, config, state = {}, w
       appendClickUpWebhookLocalLog(worktree, { type: "pending_session_metadata_failed", taskId, sessionId: pendingSessionId, message: error.message });
       throw error;
     }
-    await sendSessionEvent(openCodeClient, { sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl });
+    const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId: pendingSessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
+    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
     const nextMetadata = clearClickUpPendingSessionMetadata(setClickUpSessionMetadata(pendingMetadata, config.routing.metadataKey, pendingSessionId), config.routing.metadataKey);
     await clickupClient.updateTaskMetadata({ taskId, fieldId: config.routing.metadataFieldId, value: nextMetadata });
     const { [taskId]: _completedPending, ...remainingPending } = stateToPersist.pendingSessions || {};
     stateToPersist = { ...stateToPersist, pendingSessions: remainingPending };
-    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    return finish({ ok: true, action: "created_session", taskId, sessionId: pendingSessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryFallback: delivery.fallback });
   }
   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, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    const delivery = await deliverClickUpSessionEventWithVerification({ openCodeClient, sendSessionEvent, clickupClient, worktree, taskId, sessionId, agent: config.routing.targetAgent, text: prompt, directory: taskRoute.worktree, opencodeBaseUrl: config.opencode?.baseUrl, eventMarkers: [taskId, eventType], verifySessionEventDelivery });
+    if (!delivery.ok) return finish({ ...delivery, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+    return finish({ ok: true, action: "sent_to_existing_session", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, deliveryVerification: delivery.verification, deliveryFallback: delivery.fallback });
   }
   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, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path });
+  const blockerTag = await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "missing_session", source: "route_existing_session" });
+  return finish({ ok: true, action: "missing_session_reported", taskId, sessionId, eventKey, branch: taskRoute.branch, worktree: taskRoute.worktree, deliveryEvidencePath, evidencePath: routingMetadata.evidence_path, blockerTag });
 }
 async function routeClickUpWebhookEvent(options = {}) {
   const taskId = clickUpTaskIdFromPayload(options.payload || {});
@@ -10003,24 +10054,14 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
       });
       if (result?.ok && result.action !== "ignored") {
         routed.assigned += 1;
-        await postClickUpStartupComment({
-          clickupClient,
-          worktree,
-          taskId,
-          type: "resume",
-          comment: buildClickUpStartupResumeComment({ taskId, result })
-        });
+      } else if (result?.ok === false) {
+        routed.errors += 1;
+        if (!result.blockerTag) await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: result.reason || "startup_reconciliation_route_failed", source: "startup_reconciliation_task" });
       }
     } 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 })
-      });
+      await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_task_failed", source: "startup_reconciliation_task" });
     }
     if (!lastWebhookMs || !clickupClient?.getTaskComments) continue;
     try {
@@ -10050,6 +10091,7 @@ async function reconcileClickUpStartup({ config, state = {}, worktree = process.
     } catch (error) {
       routed.errors += 1;
       appendClickUpWebhookLocalLog(worktree, { type: "startup_reconciliation_comments_failed", taskId, message: error.message });
+      await applyClickUpBlockerTag({ clickupClient, worktree, taskId, reason: "startup_reconciliation_comments_failed", source: "startup_reconciliation_comments" });
     }
   }
   clickUpWebhookLifecycleLog(worktree, { type: "startup_reconciliation_finished", ...routed });
@@ -11834,7 +11876,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, 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 };
+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, verifyOpenCodeSessionEventDelivery, 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.37",
+  "version": "0.1.39",
   "repository": {
     "type": "git",
     "url": "git+ssh://git@github.com/defend-tech/opencode-optima.git"