@bike4mind/cli 0.2.30-subagent-delegation.19188 → 0.2.31-b4m-cli-undo-command.19493

package/dist/{chunk-ICLEQOH6.js → chunk-GE7Q64MS.js}

@@ -171,6 +171,20 @@ var ChatModels;
 })(ChatModels || (ChatModels = {}));
 var CHAT_MODELS = Object.values(ChatModels);
 var supportedChatModels = z.nativeEnum(ChatModels);
+var REASONING_SUPPORTED_MODELS = /* @__PURE__ */ new Set([
+  ChatModels.O1,
+  ChatModels.O3_MINI,
+  ChatModels.O3,
+  ChatModels.O4_MINI,
+  ChatModels.GPT5,
+  ChatModels.GPT5_MINI,
+  ChatModels.GPT5_NANO,
+  ChatModels.GPT5_CHAT_LATEST,
+  ChatModels.GPT5_1,
+  ChatModels.GPT5_1_CHAT_LATEST,
+  ChatModels.GPT5_2,
+  ChatModels.GPT5_2_CHAT_LATEST
+]);
 var SpeechToTextModels;
 (function(SpeechToTextModels2) {
   SpeechToTextModels2["WHISPER_1"] = "whisper-1";
@@ -311,8 +325,14 @@ var b4mLLMTools = z5.enum([
   "planet_visibility",
   // Knowledge base search
   "search_knowledge_base",
+  "retrieve_knowledge_content",
   // Agent delegation
-  "delegate_to_agent"
+  "delegate_to_agent",
+  // Quantum optimization tools
+  "quantum_schedule",
+  "quantum_formulate",
+  // Navigation tool
+  "navigate_view"
 ]);
 var B4MLLMToolsList = b4mLLMTools.options.map((tool) => tool);
 var RechartsChartTypeSchema = z5.enum([
@@ -1063,6 +1083,34 @@ var WebhookDeliveryStatus;
   WebhookDeliveryStatus2["Pending"] = "pending";
 })(WebhookDeliveryStatus || (WebhookDeliveryStatus = {}));
 
+// ../../b4m-core/packages/common/dist/src/types/entities/WebhookAuditLogTypes.js
+var WebhookAuditStatus;
+(function(WebhookAuditStatus2) {
+  WebhookAuditStatus2["Received"] = "received";
+  WebhookAuditStatus2["Processing"] = "processing";
+  WebhookAuditStatus2["Completed"] = "completed";
+  WebhookAuditStatus2["Failed"] = "failed";
+})(WebhookAuditStatus || (WebhookAuditStatus = {}));
+
+// ../../b4m-core/packages/common/dist/src/types/entities/JiraWebhookConfigTypes.js
+var COMMON_JIRA_WEBHOOK_EVENTS = [
+  "jira:issue_created",
+  "jira:issue_updated",
+  "comment_created",
+  "comment_updated",
+  "sprint_started",
+  "sprint_closed"
+];
+
+// ../../b4m-core/packages/common/dist/src/types/entities/JiraWebhookDeliveryTypes.js
+var JiraWebhookDeliveryStatus;
+(function(JiraWebhookDeliveryStatus2) {
+  JiraWebhookDeliveryStatus2["Success"] = "success";
+  JiraWebhookDeliveryStatus2["Failed"] = "failed";
+  JiraWebhookDeliveryStatus2["Filtered"] = "filtered";
+  JiraWebhookDeliveryStatus2["Pending"] = "pending";
+})(JiraWebhookDeliveryStatus || (JiraWebhookDeliveryStatus = {}));
+
 // ../../b4m-core/packages/common/dist/src/types/common.js
 var SupportedFabFileMimeTypes;
 (function(SupportedFabFileMimeTypes2) {
@@ -1169,6 +1217,29 @@ var VoiceSessionSendTranscriptAction = z10.object({
   conversationItemId: z10.string(),
   timestamp: z10.coerce.date().optional()
 });
+var CliCompletionRequestAction = z10.object({
+  action: z10.literal("cli_completion_request"),
+  accessToken: z10.string(),
+  requestId: z10.string().uuid(),
+  model: z10.string(),
+  messages: z10.array(z10.object({
+    role: z10.enum(["user", "assistant", "system"]),
+    content: z10.union([z10.string(), z10.array(z10.unknown())])
+  })),
+  options: z10.object({
+    temperature: z10.number().optional(),
+    maxTokens: z10.number().optional(),
+    stream: z10.boolean().optional(),
+    tools: z10.array(z10.unknown()).optional()
+  }).optional()
+});
+var CliToolRequestAction = z10.object({
+  action: z10.literal("cli_tool_request"),
+  accessToken: z10.string(),
+  requestId: z10.string().uuid(),
+  toolName: z10.string(),
+  input: z10.record(z10.unknown())
+});
 var VoiceSessionEndedAction = z10.object({
   action: z10.literal("voice_session_ended"),
   userId: z10.string(),
@@ -1457,6 +1528,36 @@ var VoiceCreditsExhaustedAction = z10.object({
   creditsUsed: z10.number(),
   clientId: z10.string().optional()
 });
+var CliCompletionChunkAction = z10.object({
+  action: z10.literal("cli_completion_chunk"),
+  requestId: z10.string(),
+  chunk: z10.object({
+    type: z10.enum(["content", "tool_use"]),
+    text: z10.string(),
+    tools: z10.array(z10.unknown()).optional(),
+    usage: z10.object({
+      inputTokens: z10.number().optional(),
+      outputTokens: z10.number().optional()
+    }).optional(),
+    thinking: z10.array(z10.unknown()).optional()
+  })
+});
+var CliCompletionDoneAction = z10.object({
+  action: z10.literal("cli_completion_done"),
+  requestId: z10.string()
+});
+var CliCompletionErrorAction = z10.object({
+  action: z10.literal("cli_completion_error"),
+  requestId: z10.string(),
+  error: z10.string()
+});
+var CliToolResponseAction = z10.object({
+  action: z10.literal("cli_tool_response"),
+  requestId: z10.string(),
+  success: z10.boolean(),
+  content: z10.unknown().optional(),
+  error: z10.string().optional()
+});
 var SessionCreatedAction = shareableDocumentSchema.extend({
   action: z10.literal("session.created"),
   id: z10.string(),
@@ -1491,7 +1592,9 @@ var MessageDataToServer = z10.discriminatedUnion("action", [
   DataUnsubscribeRequestAction,
   HeartbeatAction,
   VoiceSessionSendTranscriptAction,
-  VoiceSessionEndedAction
+  VoiceSessionEndedAction,
+  CliCompletionRequestAction,
+  CliToolRequestAction
 ]);
 var MessageDataToClient = z10.discriminatedUnion("action", [
   DataSubscriptionUpdateAction,
@@ -1517,7 +1620,11 @@ var MessageDataToClient = z10.discriminatedUnion("action", [
   PiHistoryCompleteAction,
   PiHistoryErrorAction,
   SessionCreatedAction,
-  VoiceCreditsExhaustedAction
+  VoiceCreditsExhaustedAction,
+  CliCompletionChunkAction,
+  CliCompletionDoneAction,
+  CliCompletionErrorAction,
+  CliToolResponseAction
 ]);
 
 // ../../b4m-core/packages/common/dist/src/schemas/cliCompletions.js
@@ -2401,6 +2508,8 @@ var SettingKeySchema = z21.enum([
   "githubMcpClientSecret",
   "atlassianClientId",
   "atlassianClientSecret",
+  "qWorkUrl",
+  "qWorkToken",
   // BRANDING RELATED SETTINGS
   "FacebookLink",
   "RedditLink",
@@ -2467,7 +2576,11 @@ var SettingKeySchema = z21.enum([
   // LIVEOPS TRIAGE AUTOMATION SETTINGS
   "liveopsTriageConfig",
   // HELP CENTER SETTINGS
-  "EnableHelpChat"
+  "EnableHelpChat",
+  // B4M PI SETTINGS
+  "EnableBmPi",
+  // QUANTUM CANVASSER SETTINGS
+  "EnableQuantumCanvasser"
 ]);
 var CategoryOrder = [
   "AI",
@@ -2825,6 +2938,16 @@ var API_SERVICE_GROUPS = {
       { key: "atlassianClientSecret", order: 5 }
     ]
   },
+  Q_WORK: {
+    id: "qWorkAPIService",
+    name: "Q/Work",
+    description: "Q/Work integration settings",
+    icon: "Handyman",
+    settings: [
+      { key: "qWorkUrl", order: 1 },
+      { key: "qWorkToken", order: 2 }
+    ]
+  },
   SEARCH: {
     id: "searchAPIService",
     name: "Search Service",
@@ -2888,7 +3011,9 @@ var API_SERVICE_GROUPS = {
       { key: "EnableMcpToolFiltering", order: 15 },
       { key: "McpToolFilteringMaxTools", order: 16 },
       { key: "EnableParallelToolExecution", order: 17 },
-      { key: "EnableHelpChat", order: 18 }
+      { key: "EnableHelpChat", order: 18 },
+      { key: "EnableBmPi", order: 19 },
+      { key: "EnableQuantumCanvasser", order: 20 }
     ]
   },
   NOTEBOOK: {
@@ -3706,6 +3831,25 @@ var settingsMap = {
     order: 5,
     isSensitive: true
   }),
+  qWorkUrl: makeStringSetting({
+    key: "qWorkUrl",
+    name: "Q/Work URL",
+    defaultValue: "",
+    description: "The base URL for the Q/Work API (for example: https://q.bike4mind.com).",
+    category: "Tools",
+    group: API_SERVICE_GROUPS.Q_WORK.id,
+    order: 1
+  }),
+  qWorkToken: makeStringSetting({
+    key: "qWorkToken",
+    name: "Q/Work Token",
+    defaultValue: "",
+    description: "The bearer token used to authenticate requests to Q/Work.",
+    category: "Tools",
+    group: API_SERVICE_GROUPS.Q_WORK.id,
+    order: 2,
+    isSensitive: true
+  }),
   EnableOllama: makeBooleanSetting({
     key: "EnableOllama",
     name: "Enable Ollama",
@@ -4078,6 +4222,26 @@ var settingsMap = {
     category: "Experimental",
     group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
     order: 17
+  }),
+  // B4M Pi (Project Intelligence) Settings
+  EnableBmPi: makeBooleanSetting({
+    key: "EnableBmPi",
+    name: "Enable B4M Pi",
+    defaultValue: true,
+    description: "Enable the B4M Pi (Project Intelligence) module for repository analysis, task scheduling, and team activity dashboards.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 18
+  }),
+  // OptiHashi Settings
+  EnableQuantumCanvasser: makeBooleanSetting({
+    key: "EnableQuantumCanvasser",
+    name: "Enable OptiHashi",
+    defaultValue: false,
+    description: "Enable OptiHashi, the quantum optimizer module for AI-driven optimization across classical and quantum solvers.",
+    category: "Experimental",
+    group: API_SERVICE_GROUPS.EXPERIMENTAL.id,
+    order: 18
   })
   // Add more settings as needed
 };
@@ -4600,6 +4764,16 @@ var SlackEvents;
   SlackEvents2["CHANNEL_EXPORT_FAILED"] = "Slack Channel Export Failed";
 })(SlackEvents || (SlackEvents = {}));
 
+// ../../b4m-core/packages/common/dist/src/schemas/analytics/events/help.js
+var HelpEvents;
+(function(HelpEvents2) {
+  HelpEvents2["HELP_ARTICLE_VIEW"] = "Help Article Viewed";
+  HelpEvents2["HELP_SEARCH"] = "Help Search";
+  HelpEvents2["HELP_ARTICLE_FEEDBACK"] = "Help Article Feedback";
+  HelpEvents2["HELP_CHAT_QUERY"] = "Help Chat Query";
+  HelpEvents2["HELP_CHAT_FEEDBACK"] = "Help Chat Feedback";
+})(HelpEvents || (HelpEvents = {}));
+
 // ../../b4m-core/packages/common/dist/src/schemas/team.js
 import { z as z24 } from "zod";
 var InternalTeamMemberSchema = z24.object({
@@ -7258,6 +7432,632 @@ var AgileApi = class {
   }
 };
 
+// ../../b4m-core/packages/common/dist/src/jira/webhook/format.js
+function daysUntil(dateString) {
+  const expirationDate = new Date(dateString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = expirationDate.getTime() - now.getTime();
+  return Math.ceil(diffMs / (1e3 * 60 * 60 * 24));
+}
+function formatWebhook(webhook) {
+  const daysUntilExpiry = daysUntil(webhook.expirationDate);
+  return {
+    id: webhook.id,
+    events: webhook.events,
+    jqlFilter: webhook.jqlFilter,
+    expirationDate: webhook.expirationDate,
+    daysUntilExpiry,
+    isExpiringSoon: daysUntilExpiry < 7
+  };
+}
+function formatWebhookList(response) {
+  return {
+    webhooks: response.values.map(formatWebhook),
+    total: response.total,
+    hasMore: !response.isLast
+  };
+}
+function extractAdfText(body, maxLength = 500) {
+  if (!body || typeof body !== "object")
+    return "";
+  const doc = body;
+  if (doc.type !== "doc" || !Array.isArray(doc.content))
+    return "";
+  const parts = [];
+  let totalLength = 0;
+  function walk(nodes) {
+    for (const node of nodes) {
+      if (totalLength >= maxLength)
+        return;
+      if (!node || typeof node !== "object")
+        continue;
+      const n = node;
+      if (n.type === "text" && typeof n.text === "string") {
+        const remaining = maxLength - totalLength;
+        const text = n.text.slice(0, remaining);
+        parts.push(text);
+        totalLength += text.length;
+      }
+      if (Array.isArray(n.content)) {
+        walk(n.content);
+      }
+    }
+  }
+  walk(doc.content);
+  const result = parts.join("");
+  if (totalLength >= maxLength)
+    return result + "...";
+  return result;
+}
+function escapeSlackMrkdwn(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\*/g, "\u2217").replace(/_/g, "\uFF3F").replace(/~/g, "\u223C").replace(/`/g, "\u02CB");
+}
+var PRIORITY_EMOJI = {
+  Highest: ":red_circle:",
+  High: ":large_orange_circle:",
+  Medium: ":large_yellow_circle:",
+  Low: ":large_green_circle:",
+  Lowest: ":white_circle:"
+};
+function getPriorityEmoji(priority) {
+  if (!priority)
+    return "";
+  return PRIORITY_EMOJI[priority] || ":blue_circle:";
+}
+function formatIssueEventForSlack(event, siteUrl) {
+  const { issue, webhookEvent, user, changelog } = event;
+  const { fields } = issue;
+  const priorityEmoji = getPriorityEmoji(fields.priority?.name);
+  const issueUrl = `${siteUrl}/browse/${issue.key}`;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "jira:issue_created":
+      action = "created";
+      emoji = ":new:";
+      break;
+    case "jira:issue_updated":
+      action = "updated";
+      emoji = ":pencil2:";
+      break;
+    case "jira:issue_deleted":
+      action = "deleted";
+      emoji = ":wastebasket:";
+      break;
+    default:
+      action = "changed";
+      emoji = ":bell:";
+  }
+  let changelogText = "";
+  if (changelog?.items && changelog.items.length > 0) {
+    const changes = changelog.items.slice(0, 3).map((item) => {
+      const from = escapeSlackMrkdwn(item.fromString || "None");
+      const to = escapeSlackMrkdwn(item.toString || "None");
+      if (item.field === "status") {
+        return `Status: ${from} \u2192 ${to}`;
+      }
+      if (item.field === "assignee") {
+        return `Assignee: ${escapeSlackMrkdwn(item.fromString || "Unassigned")} \u2192 ${escapeSlackMrkdwn(item.toString || "Unassigned")}`;
+      }
+      if (item.field === "priority") {
+        return `Priority: ${from} \u2192 ${to}`;
+      }
+      return `${escapeSlackMrkdwn(item.field)}: ${from} \u2192 ${to}`;
+    });
+    if (changes.length > 0) {
+      changelogText = "\n" + changes.map((c) => `\u2022 ${c}`).join("\n");
+      if (changelog.items.length > 3) {
+        changelogText += `
+_...and ${changelog.items.length - 3} more changes_`;
+      }
+    }
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} Issue ${action}: ${escapeSlackMrkdwn(issue.key)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(fields.summary)}`
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `${priorityEmoji} *Priority:* ${escapeSlackMrkdwn(fields.priority?.name || "None")}`,
+          `*Status:* ${escapeSlackMrkdwn(fields.status.name)}`,
+          `*Type:* ${escapeSlackMrkdwn(fields.issuetype.name)}`,
+          `*Assignee:* ${escapeSlackMrkdwn(fields.assignee?.displayName || "Unassigned")}`
+        ].join("  |  ")
+      }
+    }
+  ];
+  if (changelogText) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Changes:*${changelogText}`
+      }
+    });
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `${escapeSlackMrkdwn(user?.displayName || "Someone")} \u2022 ${escapeSlackMrkdwn(fields.project.name)} (${escapeSlackMrkdwn(fields.project.key)})`
+      }
+    ]
+  });
+  blocks.push({
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View in Jira",
+          emoji: true
+        },
+        url: issueUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} ${escapeSlackMrkdwn(issue.key)} ${action}: ${escapeSlackMrkdwn(fields.summary)}`
+  };
+}
+function formatCommentEventForSlack(event, siteUrl) {
+  const { issue, comment, webhookEvent } = event;
+  const issueUrl = `${siteUrl}/browse/${issue.key}`;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "comment_created":
+      action = "commented on";
+      emoji = ":speech_balloon:";
+      break;
+    case "comment_updated":
+      action = "updated comment on";
+      emoji = ":pencil:";
+      break;
+    case "comment_deleted":
+      action = "deleted comment on";
+      emoji = ":x:";
+      break;
+    default:
+      action = "commented on";
+      emoji = ":speech_balloon:";
+  }
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} ${escapeSlackMrkdwn(comment.author.displayName)} ${action} ${escapeSlackMrkdwn(issue.key)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(issue.fields.summary)}`
+      }
+    }
+  ];
+  if (webhookEvent !== "comment_deleted") {
+    const bodyText = extractAdfText(comment.body);
+    if (bodyText) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `> ${escapeSlackMrkdwn(bodyText).replace(/\n/g, "\n> ")}`
+        }
+      });
+    }
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: `${escapeSlackMrkdwn(issue.fields.project.name)} \u2022 ${escapeSlackMrkdwn(issue.fields.issuetype.name)}`
+      }
+    ]
+  }, {
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View in Jira",
+          emoji: true
+        },
+        url: issueUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} ${escapeSlackMrkdwn(comment.author.displayName)} ${action} ${escapeSlackMrkdwn(issue.key)}: ${escapeSlackMrkdwn(issue.fields.summary)}`
+  };
+}
+function formatSprintEventForSlack(event, siteUrl) {
+  const { sprint, webhookEvent, user } = event;
+  let action;
+  let emoji;
+  switch (webhookEvent) {
+    case "sprint_created":
+      action = "created";
+      emoji = ":calendar:";
+      break;
+    case "sprint_started":
+      action = "started";
+      emoji = ":rocket:";
+      break;
+    case "sprint_closed":
+      action = "completed";
+      emoji = ":checkered_flag:";
+      break;
+    case "sprint_updated":
+      action = "updated";
+      emoji = ":pencil2:";
+      break;
+    case "sprint_deleted":
+      action = "deleted";
+      emoji = ":wastebasket:";
+      break;
+    default:
+      action = "changed";
+      emoji = ":bell:";
+  }
+  const sprintUrl = `${siteUrl}/secure/RapidBoard.jspa?rapidView=${sprint.originBoardId}`;
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `${emoji} Sprint ${action}: ${escapeSlackMrkdwn(sprint.name)}`,
+        emoji: true
+      }
+    },
+    {
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: [
+          `*State:* ${escapeSlackMrkdwn(sprint.state)}`,
+          sprint.startDate ? `*Start:* ${new Date(sprint.startDate).toLocaleDateString()}` : "",
+          sprint.endDate ? `*End:* ${new Date(sprint.endDate).toLocaleDateString()}` : ""
+        ].filter(Boolean).join("  |  ")
+      }
+    }
+  ];
+  if (sprint.goal) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*Goal:* ${escapeSlackMrkdwn(sprint.goal)}`
+      }
+    });
+  }
+  blocks.push({
+    type: "context",
+    elements: [
+      {
+        type: "mrkdwn",
+        text: user?.displayName ? escapeSlackMrkdwn(user.displayName) : "System"
+      }
+    ]
+  });
+  blocks.push({
+    type: "actions",
+    elements: [
+      {
+        type: "button",
+        text: {
+          type: "plain_text",
+          text: "View Board",
+          emoji: true
+        },
+        url: sprintUrl,
+        style: "primary"
+      }
+    ]
+  });
+  return {
+    blocks,
+    text: `${emoji} Sprint ${action}: ${escapeSlackMrkdwn(sprint.name)}`
+  };
+}
+function formatGenericEventForSlack(eventType, payload, siteUrl) {
+  const issue = payload.issue;
+  const user = payload.user;
+  const issueLink = payload.issueLink;
+  const changelog = payload.changelog;
+  const project = payload.project ?? issue?.fields?.project;
+  const version = payload.version;
+  const worklog = payload.worklog;
+  const board = payload.board;
+  const readableEvent = eventType.replace(/^jira:/, "").replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  const blocks = [
+    {
+      type: "header",
+      text: {
+        type: "plain_text",
+        text: `:bell: ${readableEvent}`,
+        emoji: true
+      }
+    }
+  ];
+  const details = [];
+  if (issue?.key) {
+    const issueUrl = `${siteUrl}/browse/${issue.key}`;
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: `*<${issueUrl}|${escapeSlackMrkdwn(issue.key)}>* ${escapeSlackMrkdwn(issue.fields?.summary || "")}`
+      }
+    });
+    const meta = [];
+    if (issue.fields?.status?.name)
+      meta.push(`*Status:* ${escapeSlackMrkdwn(issue.fields.status.name)}`);
+    if (issue.fields?.issuetype?.name)
+      meta.push(`*Type:* ${escapeSlackMrkdwn(issue.fields.issuetype.name)}`);
+    if (issue.fields?.priority?.name) {
+      const emoji = getPriorityEmoji(issue.fields.priority.name);
+      meta.push(`${emoji} *Priority:* ${escapeSlackMrkdwn(issue.fields.priority.name)}`);
+    }
+    if (issue.fields?.assignee?.displayName)
+      meta.push(`*Assignee:* ${escapeSlackMrkdwn(issue.fields.assignee.displayName)}`);
+    if (meta.length > 0)
+      details.push(meta.join("  |  "));
+  }
+  if (issueLink?.issueLinkType) {
+    const linkType = issueLink.issueLinkType;
+    const linkDesc = escapeSlackMrkdwn(linkType.outwardName || linkType.name || "linked");
+    details.push(`*Link type:* ${linkDesc}`);
+    if (issueLink.sourceIssueId)
+      details.push(`*Source issue ID:* ${issueLink.sourceIssueId}`);
+    if (issueLink.destinationIssueId)
+      details.push(`*Destination issue ID:* ${issueLink.destinationIssueId}`);
+  }
+  if (version?.name) {
+    const versionParts = [`*Version:* ${escapeSlackMrkdwn(version.name)}`];
+    if (version.description)
+      versionParts.push(escapeSlackMrkdwn(version.description));
+    if (version.released !== void 0)
+      versionParts.push(version.released ? ":white_check_mark: Released" : "Unreleased");
+    details.push(versionParts.join("  |  "));
+  }
+  if (worklog) {
+    const wlParts = [];
+    if (worklog.author?.displayName)
+      wlParts.push(`*By:* ${escapeSlackMrkdwn(worklog.author.displayName)}`);
+    if (worklog.timeSpent)
+      wlParts.push(`*Time:* ${escapeSlackMrkdwn(worklog.timeSpent)}`);
+    if (wlParts.length > 0)
+      details.push(wlParts.join("  |  "));
+  }
+  if (board?.name) {
+    details.push(`*Board:* ${escapeSlackMrkdwn(board.name)}`);
+  }
+  if (changelog?.items && changelog.items.length > 0) {
+    const changes = changelog.items.slice(0, 3).map((item) => `\u2022 ${escapeSlackMrkdwn(item.field || "")}: ${escapeSlackMrkdwn(item.fromString || "None")} \u2192 ${escapeSlackMrkdwn(item.toString || "None")}`);
+    if (changelog.items.length > 3) {
+      changes.push(`_...and ${changelog.items.length - 3} more_`);
+    }
+    details.push(`*Changes:*
+${changes.join("\n")}`);
+  }
+  if (details.length > 0) {
+    blocks.push({
+      type: "section",
+      text: {
+        type: "mrkdwn",
+        text: details.join("\n")
+      }
+    });
+  }
+  const contextParts = [];
+  if (user?.displayName)
+    contextParts.push(escapeSlackMrkdwn(user.displayName));
+  if (project?.name)
+    contextParts.push(`${escapeSlackMrkdwn(project.name)}${project.key ? ` (${escapeSlackMrkdwn(project.key)})` : ""}`);
+  if (contextParts.length > 0) {
+    blocks.push({
+      type: "context",
+      elements: [{ type: "mrkdwn", text: contextParts.join(" \u2022 ") }]
+    });
+  }
+  if (issue?.key) {
+    const issueUrl = `${siteUrl}/browse/${issue.key}`;
+    blocks.push({
+      type: "actions",
+      elements: [
+        {
+          type: "button",
+          text: { type: "plain_text", text: "View in Jira", emoji: true },
+          url: issueUrl,
+          style: "primary"
+        }
+      ]
+    });
+  }
+  const summary = issue?.key ? `${escapeSlackMrkdwn(issue.key)}: ${escapeSlackMrkdwn(issue.fields?.summary || readableEvent)}` : readableEvent;
+  return {
+    blocks,
+    text: `:bell: ${summary}`
+  };
+}
+
+// ../../b4m-core/packages/common/dist/src/jira/webhook/api.js
+var WebhookApi = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Build URL for webhook API endpoints.
+   *
+   * Note: Webhooks use a different base URL than other Jira APIs.
+   */
+  buildUrl(path, query = {}) {
+    const url = new URL(`${this.config.apiBaseUrl}${path}`);
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.append(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  /**
+   * Make an authenticated request to the Jira Webhook API.
+   */
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const headers = {
+      Authorization: this.config.authHeader,
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    };
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Jira Webhook API error (${response.status}): ${errorBody}`);
+    }
+    if (response.status === 204) {
+      return {};
+    }
+    const data = await response.json();
+    return data;
+  }
+  // ============================================================================
+  // Webhook CRUD Operations
+  // ============================================================================
+  /**
+   * List all webhooks registered by this OAuth app.
+   *
+   * @param startAt - Pagination start index (default: 0)
+   * @param maxResults - Max results per page (default: 50, max: 100)
+   */
+  async listWebhooks(params = {}) {
+    const { startAt = 0, maxResults = 50 } = params;
+    const response = await this.request("GET", "/webhook", {
+      query: { startAt, maxResults }
+    });
+    return formatWebhookList(response);
+  }
+  /**
+   * Register a new webhook.
+   *
+   * @param url - The URL where Jira will POST webhook events
+   * @param events - Events to subscribe to
+   * @param jqlFilter - Optional JQL filter (only matching issues trigger events)
+   * @returns The created webhook ID
+   */
+  async registerWebhook(params) {
+    const { url, events, jqlFilter } = params;
+    const webhook = {
+      // Jira webhook API requires jqlFilter but has limited operator support.
+      // "IS NOT EMPTY" and empty strings are rejected. Use a universally-true expression.
+      jqlFilter: jqlFilter || "project != null",
+      events
+    };
+    const body = {
+      url,
+      webhooks: [webhook]
+    };
+    const response = await this.request("POST", "/webhook", {
+      body
+    });
+    console.log("[JIRA-WEBHOOK-API] registerWebhook raw response:", JSON.stringify(response, null, 2));
+    if (!response.webhookRegistrationResult || response.webhookRegistrationResult.length === 0) {
+      throw new Error("Failed to register webhook: No registration result returned");
+    }
+    const result = response.webhookRegistrationResult[0];
+    if (result.errors && result.errors.length > 0) {
+      throw new Error(`Failed to register webhook: ${result.errors.join(", ")}`);
+    }
+    if (result.createdWebhookId === void 0 || result.createdWebhookId === null) {
+      throw new Error(`Failed to register webhook: No webhook ID in response. Full result: ${JSON.stringify(result)}`);
+    }
+    return {
+      webhookId: result.createdWebhookId
+    };
+  }
+  /**
+   * Refresh webhook expiration dates.
+   *
+   * Jira webhooks expire after 30 days. Call this to extend expiration.
+   *
+   * @param webhookIds - IDs of webhooks to refresh
+   * @returns New expiration date
+   */
+  async refreshWebhooks(params) {
+    const { webhookIds } = params;
+    const body = {
+      webhookIds
+    };
+    const response = await this.request("PUT", "/webhook/refresh", {
+      body
+    });
+    return {
+      expirationDate: response.expirationDate
+    };
+  }
+  /**
+   * Delete webhooks by ID.
+   *
+   * @param webhookIds - IDs of webhooks to delete
+   */
+  async deleteWebhooks(params) {
+    const { webhookIds } = params;
+    const body = {
+      webhookIds
+    };
+    await this.request("DELETE", "/webhook", {
+      body
+    });
+  }
+  /**
+   * Get a specific webhook by ID.
+   *
+   * Note: Jira API doesn't have a direct "get by ID" endpoint,
+   * so we list and filter.
+   */
+  async getWebhook(params) {
+    const { webhookId } = params;
+    const response = await this.request("GET", "/webhook", {
+      query: { startAt: 0, maxResults: 100 }
+    });
+    const webhook = response.values.find((w) => w.id === webhookId);
+    return webhook || null;
+  }
+};
+
 // ../../b4m-core/packages/common/dist/src/jira/api.js
 var JIRA_MAX_ATTACHMENT_SIZE = 20 * 1024 * 1024;
 function isValidIssueKey(key) {
@@ -8009,8 +8809,71 @@ var JiraApi = class {
     }
     return this._agileApi;
   }
+  // ============================================================================
+  // Webhook API Access (Webhook Management)
+  // ============================================================================
+  _webhookApi = null;
+  /**
+   * Get the Webhook API client for webhook management operations.
+   * Lazily instantiated on first access.
+   */
+  get webhook() {
+    if (!this._webhookApi) {
+      this._webhookApi = new WebhookApi(this.config);
+    }
+    return this._webhookApi;
+  }
 };
 
+// ../../b4m-core/packages/common/dist/src/jira/webhook/types.js
+function isIssueWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("jira:issue_"))
+    return false;
+  const issue = payload.issue;
+  if (!issue || typeof issue.key !== "string")
+    return false;
+  const fields = issue.fields;
+  if (!fields || typeof fields.summary !== "string")
+    return false;
+  const status = fields.status;
+  const issuetype = fields.issuetype;
+  const project = fields.project;
+  if (!status?.name || !issuetype?.name || !project?.key)
+    return false;
+  return true;
+}
+function isCommentWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("comment_"))
+    return false;
+  const issue = payload.issue;
+  if (!issue || typeof issue.key !== "string")
+    return false;
+  const comment = payload.comment;
+  if (!comment || typeof comment.id !== "string")
+    return false;
+  const author = comment.author;
+  if (!author || typeof author.displayName !== "string")
+    return false;
+  return true;
+}
+function isSprintWebhookEvent(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || !event.startsWith("sprint_"))
+    return false;
+  const sprint = payload.sprint;
+  if (!sprint || typeof sprint.name !== "string")
+    return false;
+  return true;
+}
+function extractWebhookEventType(payload) {
+  const event = payload.webhookEvent;
+  if (typeof event !== "string" || event.length === 0)
+    return null;
+  return event;
+}
+
 // ../../b4m-core/packages/common/dist/src/atlassian/config.js
 function getErrorMessage(error) {
   if (error instanceof Error) {
@@ -8575,6 +9438,679 @@ function serializeSSEEvent(event) {
 }
 var SSE_DONE_SIGNAL = "data: [DONE]\n\n";
 
+// ../../b4m-core/packages/common/dist/src/navigation/viewRegistry.js
+var VIEW_REGISTRY = [
+  // ── OptiHashi (Quantum Optimizer) ──────────────────────────────────────
+  {
+    id: "opti.root",
+    section: "opti",
+    label: "OptiHashi Home",
+    description: "The OptiHashi Quantum Optimizer landing page showing all 8 pattern family cards",
+    navigationType: "route",
+    target: "/opti",
+    keywords: ["optimization", "canvasser", "home", "patterns", "families"]
+  },
+  {
+    id: "opti.scheduling",
+    section: "opti",
+    label: "Scheduling",
+    description: "Scheduling optimization: job-shop, flow-shop, shift scheduling, makespan minimization",
+    navigationType: "action",
+    target: "scheduling",
+    keywords: ["scheduling", "job-shop", "flow-shop", "shifts", "makespan", "calendar"]
+  },
+  {
+    id: "opti.scheduling.problem",
+    section: "opti",
+    label: "Problem Editor",
+    description: "Define and preview scheduling problems \u2014 job-shop matrix, QUBO encoding",
+    navigationType: "action",
+    target: "scheduling.problem",
+    keywords: ["problem", "editor", "QUBO", "matrix", "jobs", "machines", "operations", "custom problem"]
+  },
+  {
+    id: "opti.scheduling.solvers",
+    section: "opti",
+    label: "Solver Selection",
+    description: "Configure which solvers to race \u2014 greedy, simulated annealing, tabu search, genetic algorithm, ant colony",
+    navigationType: "action",
+    target: "scheduling.solvers",
+    keywords: [
+      "solvers",
+      "tabu",
+      "simulated annealing",
+      "genetic algorithm",
+      "ant colony",
+      "greedy",
+      "solver race",
+      "configure solvers"
+    ]
+  },
+  {
+    id: "opti.scheduling.results",
+    section: "opti",
+    label: "Race Results",
+    description: "View solver race results \u2014 progress, best schedule, makespan comparison, utilization",
+    navigationType: "action",
+    target: "scheduling.results",
+    keywords: [
+      "results",
+      "race results",
+      "makespan",
+      "comparison",
+      "best schedule",
+      "utilization",
+      "solver comparison"
+    ]
+  },
+  {
+    id: "opti.scheduling.gantt",
+    section: "opti",
+    label: "Gantt Chart",
+    description: "Gantt chart visualization of the best scheduling solution",
+    navigationType: "action",
+    target: "scheduling.gantt",
+    keywords: ["gantt", "chart", "visualization", "timeline", "schedule view"]
+  },
+  {
+    id: "opti.scheduling.qwork",
+    section: "opti",
+    label: "Q/Work",
+    description: "View quantum job history and status from Q/Work",
+    navigationType: "action",
+    target: "scheduling.qwork",
+    keywords: ["quantum", "q/work", "qwork", "hardware", "quantum computer", "jobs", "status", "history"]
+  },
+  {
+    id: "opti.routing",
+    section: "opti",
+    label: "Routing",
+    description: "Vehicle routing, TSP, logistics, delivery routes, fleet management",
+    navigationType: "action",
+    target: "routing",
+    keywords: ["routing", "TSP", "vehicle", "logistics", "delivery", "fleet", "path"]
+  },
+  {
+    id: "opti.packing",
+    section: "opti",
+    label: "Packing",
+    description: "Bin packing, knapsack, container loading, space optimization",
+    navigationType: "action",
+    target: "packing",
+    keywords: ["packing", "bin", "knapsack", "container", "loading", "space"]
+  },
+  {
+    id: "opti.network",
+    section: "opti",
+    label: "Network Design",
+    description: "Network flow, facility location, supply chain network design",
+    navigationType: "action",
+    target: "network",
+    keywords: ["network", "flow", "facility", "location", "supply chain", "graph"]
+  },
+  {
+    id: "opti.selection",
+    section: "opti",
+    label: "Selection",
+    description: "Portfolio selection, feature selection, subset optimization",
+    navigationType: "action",
+    target: "selection",
+    keywords: ["selection", "portfolio", "feature", "subset", "pick", "choose"]
+  },
+  {
+    id: "opti.economic",
+    section: "opti",
+    label: "Economic",
+    description: "Resource allocation, pricing, budgeting, economic optimization",
+    navigationType: "action",
+    target: "economic",
+    keywords: ["economic", "resource", "allocation", "pricing", "budget", "cost"]
+  },
+  {
+    id: "opti.assignment",
+    section: "opti",
+    label: "Assignment",
+    description: "Task assignment, matching, workforce allocation, team formation",
+    navigationType: "action",
+    target: "assignment",
+    keywords: ["assignment", "matching", "workforce", "team", "allocate", "assign"]
+  },
+  {
+    id: "opti.partitioning",
+    section: "opti",
+    label: "Partitioning",
+    description: "Graph partitioning, clustering, load balancing, data partitioning",
+    navigationType: "action",
+    target: "partitioning",
+    keywords: ["partitioning", "clustering", "balancing", "partition", "divide", "split"]
+  },
+  // ── Admin ──────────────────────────────────────────────────────────────
+  {
+    id: "admin.users",
+    section: "admin",
+    label: "User Management",
+    description: "View and manage user accounts, roles, and permissions",
+    navigationType: "tab",
+    target: "0",
+    // AdminTab.Users
+    keywords: ["users", "accounts", "roles", "permissions", "manage users"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.credit_analytics",
+    section: "admin",
+    label: "Credit Analytics",
+    description: "View credit usage, add credits to users, billing analytics",
+    navigationType: "tab",
+    target: "15",
+    // AdminTab.CreditAnalytics
+    keywords: ["credits", "billing", "usage", "add credits", "balance", "cost"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.settings",
+    section: "admin",
+    label: "Admin Settings",
+    description: "System-wide administration settings and configuration",
+    navigationType: "tab",
+    target: "1",
+    // AdminTab.AdminSettings
+    keywords: ["settings", "configuration", "admin", "system settings"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.system_health",
+    section: "admin",
+    label: "System Health",
+    description: "Monitor system health, uptime, and performance metrics",
+    navigationType: "tab",
+    target: "29",
+    // AdminTab.SystemHealth
+    keywords: ["health", "uptime", "monitoring", "performance", "status"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.llm_dashboard",
+    section: "admin",
+    label: "LLM Dashboard",
+    description: "LLM model usage, costs, and performance monitoring",
+    navigationType: "tab",
+    target: "24",
+    // AdminTab.LLMDashboard
+    keywords: ["llm", "model", "ai", "costs", "tokens", "dashboard"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.tool_definitions",
+    section: "admin",
+    label: "Tool Definitions",
+    description: "Manage LLM tool definitions and configurations",
+    navigationType: "tab",
+    target: "31",
+    // AdminTab.ToolDefinitions
+    keywords: ["tools", "tool definitions", "functions", "capabilities"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.organizations",
+    section: "admin",
+    label: "Organizations",
+    description: "Manage organizations, teams, and multi-tenant settings",
+    navigationType: "tab",
+    target: "14",
+    // AdminTab.Organizations
+    keywords: ["organizations", "teams", "tenants", "companies"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.analytics",
+    section: "admin",
+    label: "Analytics",
+    description: "User activity analytics, engagement metrics, and reports",
+    navigationType: "tab",
+    target: "3",
+    // AdminTab.Analytics
+    keywords: ["analytics", "metrics", "reports", "engagement", "activity"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.subscribers",
+    section: "admin",
+    label: "Subscribers",
+    description: "Manage subscriber waitlist and access approvals",
+    navigationType: "tab",
+    target: "12",
+    // AdminTab.Subscribers
+    keywords: ["subscribers", "waitlist", "approvals", "signups"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.subscriptions",
+    section: "admin",
+    label: "Subscriptions",
+    description: "Manage subscription plans, tiers, and billing",
+    navigationType: "tab",
+    target: "13",
+    // AdminTab.Subscriptions
+    keywords: ["subscriptions", "plans", "tiers", "billing", "pricing"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.invite_codes",
+    section: "admin",
+    label: "Invite Codes",
+    description: "Create and manage registration invite codes",
+    navigationType: "tab",
+    target: "5",
+    // AdminTab.RegistrationInvites
+    keywords: ["invite", "codes", "registration", "invitations"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.agent_ops",
+    section: "admin",
+    label: "Agent Operations",
+    description: "Monitor and manage AI agent operations and tasks",
+    navigationType: "tab",
+    target: "23",
+    // AdminTab.AgentOps
+    keywords: ["agents", "operations", "tasks", "agent ops"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.security_dashboard",
+    section: "admin",
+    label: "Security Dashboard",
+    description: "Security monitoring, threat detection, and audit logs",
+    navigationType: "tab",
+    target: "26",
+    // AdminTab.SecurityDashboard
+    keywords: ["security", "threats", "audit", "logs", "vulnerabilities"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.system_prompts",
+    section: "admin",
+    label: "System Prompts",
+    description: "Edit and manage system prompts for AI models",
+    navigationType: "tab",
+    target: "21",
+    // AdminTab.SystemPrompts
+    keywords: ["prompts", "system prompts", "instructions", "AI prompts"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.modals",
+    section: "admin",
+    label: "Modals",
+    description: "Manage modal dialogs and popup configurations",
+    navigationType: "tab",
+    target: "7",
+    // AdminTab.Modals
+    keywords: ["modals", "dialogs", "popups", "announcements"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.whats_new",
+    section: "admin",
+    label: "What&apos;s New",
+    description: "Manage What&apos;s New release notes and changelogs",
+    navigationType: "tab",
+    target: "32",
+    // AdminTab.WhatsNewModals
+    keywords: ["whats new", "release notes", "changelog", "updates"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.rapid_reply",
+    section: "admin",
+    label: "Rapid Reply",
+    description: "Configure rapid reply templates and shortcuts",
+    navigationType: "tab",
+    target: "25",
+    // AdminTab.RapidReply
+    keywords: ["rapid reply", "templates", "shortcuts", "quick responses"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.slack_workspaces",
+    section: "admin",
+    label: "Slack Workspaces",
+    description: "Manage connected Slack workspace integrations",
+    navigationType: "tab",
+    target: "30",
+    // AdminTab.SlackWorkspaces
+    keywords: ["slack", "workspaces", "integrations", "messaging"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.secrets_rotation",
+    section: "admin",
+    label: "Secrets Rotation",
+    description: "Manage API key rotation and secret lifecycle",
+    navigationType: "tab",
+    target: "16",
+    // AdminTab.SecretsRotation
+    keywords: ["secrets", "rotation", "API keys", "credentials"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.bulk_import",
+    section: "admin",
+    label: "Bulk Import",
+    description: "Bulk import users and data from CSV or other formats",
+    navigationType: "tab",
+    target: "17",
+    // AdminTab.BulkImport
+    keywords: ["bulk", "import", "CSV", "migration", "data import"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.feedbacks",
+    section: "admin",
+    label: "Feedbacks",
+    description: "View and manage user feedback, bug reports, and feature requests",
+    navigationType: "tab",
+    target: "2",
+    // AdminTab.Feedbacks
+    keywords: ["feedback", "bug reports", "feature requests", "user feedback", "complaints"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.files",
+    section: "admin",
+    label: "Files",
+    description: "Manage uploaded files across all users, storage analytics",
+    navigationType: "tab",
+    target: "8",
+    // AdminTab.Files
+    keywords: ["files", "uploads", "storage", "documents", "file management"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.documentation",
+    section: "admin",
+    label: "Documentation",
+    description: "System documentation and internal reference guides",
+    navigationType: "tab",
+    target: "9",
+    // AdminTab.Documentation
+    keywords: ["documentation", "docs", "guides", "reference", "help docs"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.world_time",
+    section: "admin",
+    label: "World Time",
+    description: "View current time across multiple time zones",
+    navigationType: "tab",
+    target: "10",
+    // AdminTab.WorldTime
+    keywords: ["world time", "time zones", "clocks", "UTC", "international time"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.model_logs",
+    section: "admin",
+    label: "Model Logs",
+    description: "View LLM model request/response logs and debugging information",
+    navigationType: "tab",
+    target: "18",
+    // AdminTab.ModelLogs
+    keywords: ["model logs", "LLM logs", "request logs", "debugging", "API logs"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.model_metrics",
+    section: "admin",
+    label: "Model Metrics",
+    description: "LLM model performance metrics, latency, and usage statistics",
+    navigationType: "tab",
+    target: "19",
+    // AdminTab.ModelMetrics
+    keywords: ["model metrics", "performance", "latency", "tokens", "model usage"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.event_metrics",
+    section: "admin",
+    label: "Event Metrics",
+    description: "Track system events, user activity events, and event analytics",
+    navigationType: "tab",
+    target: "20",
+    // AdminTab.EventMetrics
+    keywords: ["event metrics", "events", "activity tracking", "event analytics"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.identity_providers",
+    section: "admin",
+    label: "Identity Providers",
+    description: "Configure SSO, SAML, and identity provider integrations",
+    navigationType: "tab",
+    target: "22",
+    // AdminTab.IdentityProviders
+    keywords: ["identity", "SSO", "SAML", "providers", "authentication", "login providers"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.email_verification",
+    section: "admin",
+    label: "Email Verification",
+    description: "Manage email verification status and send verification emails",
+    navigationType: "tab",
+    target: "27",
+    // AdminTab.EmailVerification
+    keywords: ["email", "verification", "verify email", "email status"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.team",
+    section: "admin",
+    label: "Team",
+    description: "Manage team members, roles, and team settings",
+    navigationType: "tab",
+    target: "28",
+    // AdminTab.Team
+    keywords: ["team", "members", "roles", "team management", "staff"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.slack_metrics",
+    section: "admin",
+    label: "Slack Metrics",
+    description: "Slack integration usage metrics and message analytics",
+    navigationType: "tab",
+    target: "33",
+    // AdminTab.SlackMetrics
+    keywords: ["slack metrics", "slack usage", "message analytics", "slack stats"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.system_secrets",
+    section: "admin",
+    label: "System Secrets",
+    description: "View and manage system-level secrets and environment variables",
+    navigationType: "tab",
+    target: "34",
+    // AdminTab.SystemSecrets
+    keywords: ["system secrets", "environment variables", "env vars", "secrets", "configuration"],
+    requiresAdmin: true
+  },
+  {
+    id: "admin.liveops_triage",
+    section: "admin",
+    label: "LiveOps Triage",
+    description: "Real-time error triage, production issue monitoring, and incident response",
+    navigationType: "tab",
+    target: "35",
+    // AdminTab.LiveOpsTriage
+    keywords: ["liveops", "triage", "errors", "incidents", "production issues", "monitoring"],
+    requiresAdmin: true
+  },
+  // ── Global ─────────────────────────────────────────────────────────────
+  {
+    id: "global.chat",
+    section: "global",
+    label: "Chat",
+    description: "Main AI chat interface for conversations",
+    navigationType: "route",
+    target: "/",
+    keywords: ["chat", "conversation", "talk", "message", "ask"]
+  },
+  {
+    id: "global.projects",
+    section: "global",
+    label: "Projects",
+    description: "View and manage projects and workspaces",
+    navigationType: "route",
+    target: "/projects",
+    keywords: ["projects", "workspaces", "organize", "folders"]
+  },
+  {
+    id: "global.agents",
+    section: "global",
+    label: "Agents",
+    description: "Browse and configure AI agents",
+    navigationType: "route",
+    target: "/agents",
+    keywords: ["agents", "AI assistants", "bots", "configure agents"]
+  },
+  {
+    id: "global.agents_create",
+    section: "global",
+    label: "Create Agent",
+    description: "Create a new AI agent with personality, motivation, system prompt, and capabilities",
+    navigationType: "route",
+    target: "/agents/new",
+    keywords: ["create agent", "new agent", "build agent", "agent personality", "agent motivation", "agent setup"]
+  },
+  {
+    id: "global.profile",
+    section: "global",
+    label: "Profile",
+    description: "User profile settings and preferences",
+    navigationType: "route",
+    target: "/profile",
+    keywords: ["profile", "account", "preferences", "personal settings"]
+  },
+  {
+    id: "global.profile_security",
+    section: "global",
+    label: "Security Settings",
+    description: "MFA, password, and security settings for your account",
+    navigationType: "route",
+    target: "/profile/security",
+    keywords: ["security", "MFA", "password", "two-factor", "2FA"]
+  },
+  {
+    id: "global.profile_api_keys",
+    section: "global",
+    label: "API Keys",
+    description: "Manage your personal API keys for integrations",
+    navigationType: "route",
+    target: "/profile/api-keys",
+    keywords: ["API keys", "tokens", "integrations", "developer"]
+  },
+  {
+    id: "global.admin",
+    section: "global",
+    label: "Admin Panel",
+    description: "Admin dashboard for system management",
+    navigationType: "route",
+    target: "/admin",
+    keywords: ["admin", "dashboard", "management", "administration"],
+    requiresAdmin: true
+  },
+  {
+    id: "global.help",
+    section: "global",
+    label: "Help",
+    description: "Help documentation and support resources",
+    navigationType: "route",
+    target: "/help",
+    keywords: ["help", "support", "documentation", "FAQ", "guide"]
+  },
+  {
+    id: "global.knowledge_base",
+    section: "global",
+    label: "Knowledge Base",
+    description: "Browse uploaded files and documents in your knowledge base",
+    navigationType: "route",
+    target: "/knowledge",
+    keywords: ["knowledge", "files", "documents", "uploads", "library"]
+  },
+  {
+    id: "global.settings",
+    section: "global",
+    label: "Settings",
+    description: "Application settings and preferences",
+    navigationType: "route",
+    target: "/settings",
+    keywords: ["settings", "preferences", "configuration", "options"]
+  }
+];
+function getViewById(viewId) {
+  return VIEW_REGISTRY.find((v) => v.id === viewId);
+}
+function getFilteredViews(options) {
+  return VIEW_REGISTRY.filter((v) => {
+    if (options?.section && v.section !== options.section)
+      return false;
+    if (v.requiresAdmin && !options?.isAdmin)
+      return false;
+    return true;
+  });
+}
+function getViewSummaryForLLM(options) {
+  const views = getFilteredViews(options);
+  const grouped = {};
+  for (const v of views) {
+    const key = v.section.toUpperCase();
+    if (!grouped[key])
+      grouped[key] = [];
+    grouped[key].push(`- ${v.id}: ${v.label} \u2014 ${v.description}`);
+  }
+  const sections = Object.entries(grouped).map(([section, lines]) => `[${section}]
+${lines.join("\n")}`).join("\n\n");
+  return [
+    "# MANDATORY: navigate_view Tool Usage",
+    "",
+    "You have a navigate_view tool that renders clickable navigation buttons in your response.",
+    "",
+    "RULE: If your response mentions or relates to ANY view listed below, you MUST call the navigate_view tool.",
+    "Do NOT just mention a view in text \u2014 you MUST also call the tool so the user sees a clickable button.",
+    "Call navigate_view AND write your text answer. Both. Every time.",
+    "",
+    "Example \u2014 if the user asks about scheduling:",
+    '1. Call navigate_view with suggestions: [{viewId: "opti.scheduling", reason: "Try scheduling algorithms here"}]',
+    "2. AND write your text answer about scheduling",
+    "",
+    "Example \u2014 if the user asks about user management:",
+    '1. Call navigate_view with suggestions: [{viewId: "admin.users", reason: "Manage user accounts"}]',
+    "2. AND write your text answer about user management",
+    "",
+    sections
+  ].join("\n");
+}
+function resolveNavigationIntents(suggestions, isAdmin) {
+  return suggestions.map((s) => {
+    const view = getViewById(s.viewId);
+    if (!view)
+      return null;
+    if (view.requiresAdmin && !isAdmin)
+      return null;
+    return {
+      viewId: view.id,
+      label: view.label,
+      description: view.description,
+      navigationType: view.navigationType,
+      target: view.target,
+      reason: s.reason
+    };
+  }).filter((intent) => intent !== null);
+}
+
 // ../../b4m-core/packages/common/dist/src/utils/dayjsConfig.js
 import dayjs from "dayjs";
 import timezone from "dayjs/plugin/timezone.js";
@@ -8597,6 +10133,7 @@ export {
   ChatModels,
   CHAT_MODELS,
   supportedChatModels,
+  REASONING_SUPPORTED_MODELS,
   SpeechToTextModels,
   SPEECH_TO_TEXT_MODELS,
   supportedSpeechToTextModels,
@@ -8703,6 +10240,9 @@ export {
   isPlaceholderValue,
   SecretAuditEvents,
   WebhookDeliveryStatus,
+  WebhookAuditStatus,
+  COMMON_JIRA_WEBHOOK_EVENTS,
+  JiraWebhookDeliveryStatus,
   SupportedFabFileMimeTypes,
   REASONING_EFFORT_LABELS,
   REASONING_EFFORT_DESCRIPTIONS,
@@ -8711,6 +10251,8 @@ export {
   DataUnsubscribeRequestAction,
   HeartbeatAction,
   VoiceSessionSendTranscriptAction,
+  CliCompletionRequestAction,
+  CliToolRequestAction,
   VoiceSessionEndedAction,
   DataSubscriptionUpdateAction,
   LLMStatusUpdateAction,
@@ -8735,6 +10277,10 @@ export {
   ImportHistoryJobProgressUpdateAction,
   ResearchModeStreamAction,
   VoiceCreditsExhaustedAction,
+  CliCompletionChunkAction,
+  CliCompletionDoneAction,
+  CliCompletionErrorAction,
+  CliToolResponseAction,
   SessionCreatedAction,
   MessageDataToServer,
   MessageDataToClient,
@@ -8823,6 +10369,7 @@ export {
   OrganizationEvents,
   UserApiKeyEvents,
   SlackEvents,
+  HelpEvents,
   InternalTeamMemberSchema,
   InternalTeamMemberListSchema,
   LatticeDataTypeSchema,
@@ -8940,11 +10487,24 @@ export {
   formatIssueLinkTypes,
   formatIssueLinks,
   AgileApi,
+  formatWebhook,
+  formatWebhookList,
+  extractAdfText,
+  escapeSlackMrkdwn,
+  formatIssueEventForSlack,
+  formatCommentEventForSlack,
+  formatSprintEventForSlack,
+  formatGenericEventForSlack,
+  WebhookApi,
   JIRA_MAX_ATTACHMENT_SIZE,
   isValidIssueKey,
   wikiMarkupToAdf,
   containsWikiTable,
   JiraApi,
+  isIssueWebhookEvent,
+  isCommentWebhookEvent,
+  isSprintWebhookEvent,
+  extractWebhookEventType,
   getErrorMessage,
   getAtlassianConfig,
   MCP_PROVIDER_METADATA,
@@ -9005,5 +10565,10 @@ export {
   formatSSEError,
   serializeSSEEvent,
   SSE_DONE_SIGNAL,
+  VIEW_REGISTRY,
+  getViewById,
+  getFilteredViews,
+  getViewSummaryForLLM,
+  resolveNavigationIntents,
   dayjsConfig_default
 };