@orchestra-mcp/tasks 0.2.0

package/dist/index.js

@@ -0,0 +1,4946 @@
+import {
+  mcpCall
+} from "./chunk-ESY4NTC7.js";
+
+// src/BacklogView/BacklogView.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var TYPE_ICONS = {
+  task: "\u2611",
+  bug: "\u{1F41B}",
+  story: "\u{1F4D6}",
+  epic: "\u26A1"
+};
+var getInitials = (name) => name.split(" ").map((w) => w[0]).join("").toUpperCase().slice(0, 2);
+var BacklogView = ({
+  columns,
+  onCardClick,
+  compact = false
+}) => {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `backlog ${compact ? "backlog--compact" : ""}`,
+      "data-testid": "backlog-view",
+      children: columns.map((col) => /* @__PURE__ */ jsxs("div", { className: "backlog__column", "data-testid": `column-${col.id}`, children: [
+        /* @__PURE__ */ jsxs("div", { className: "backlog__column-header", children: [
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "backlog__column-dot",
+              style: { backgroundColor: col.color || "var(--color-accent)" }
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { className: "backlog__column-title", children: col.title }),
+          /* @__PURE__ */ jsx("span", { className: "backlog__column-count", "data-testid": `count-${col.id}`, children: col.cards.length })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "backlog__cards", children: col.cards.map((card) => /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            className: "backlog__card",
+            "data-testid": `card-${card.id}`,
+            onClick: () => onCardClick?.(card),
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "backlog__card-top", children: [
+                card.type && /* @__PURE__ */ jsx("span", { className: "backlog__card-type", "data-testid": `type-${card.id}`, children: TYPE_ICONS[card.type] || card.type }),
+                card.priority && /* @__PURE__ */ jsx(
+                  "span",
+                  {
+                    className: `backlog__card-priority backlog__card-priority--${card.priority}`,
+                    "data-testid": `priority-${card.id}`
+                  }
+                )
+              ] }),
+              /* @__PURE__ */ jsx("span", { className: "backlog__card-title", children: card.title }),
+              card.description && /* @__PURE__ */ jsx("span", { className: "backlog__card-desc", children: card.description }),
+              /* @__PURE__ */ jsxs("div", { className: "backlog__card-bottom", children: [
+                card.tags && card.tags.length > 0 && /* @__PURE__ */ jsx("div", { className: "backlog__card-tags", "data-testid": `tags-${card.id}`, children: card.tags.map((tag) => /* @__PURE__ */ jsx("span", { className: "backlog__card-tag", children: tag }, tag)) }),
+                card.assignee && /* @__PURE__ */ jsx("span", { className: "backlog__card-assignee", "data-testid": `assignee-${card.id}`, children: getInitials(card.assignee) })
+              ] })
+            ]
+          },
+          card.id
+        )) })
+      ] }, col.id))
+    }
+  );
+};
+
+// src/StatusGrid/StatusGrid.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var StatusGrid = ({ items, onStatusClick, activeStatus }) => {
+  if (items.length === 0) return null;
+  return /* @__PURE__ */ jsx2("div", { className: "status-grid", "data-testid": "status-grid", children: items.map((item) => /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      type: "button",
+      className: [
+        "status-grid__cell",
+        activeStatus === item.status ? "status-grid__cell--active" : ""
+      ].filter(Boolean).join(" "),
+      "data-testid": `status-${item.status}`,
+      onClick: () => onStatusClick?.(item.status),
+      children: [
+        /* @__PURE__ */ jsx2(
+          "span",
+          {
+            className: "status-grid__dot",
+            style: { backgroundColor: item.color || "var(--color-accent)" }
+          }
+        ),
+        /* @__PURE__ */ jsx2("span", { className: "status-grid__label", children: item.label }),
+        /* @__PURE__ */ jsx2("span", { className: "status-grid__count", children: item.count })
+      ]
+    },
+    item.status
+  )) });
+};
+
+// src/TaskList/TaskList.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var PRIORITY_COLORS = {
+  low: "#22c55e",
+  medium: "#eab308",
+  high: "#f97316",
+  critical: "#ef4444"
+};
+var TYPE_ICONS2 = {
+  task: "\u2611",
+  bug: "\u{1F41B}",
+  hotfix: "\u{1F525}",
+  story: "\u{1F4D6}",
+  epic: "\u26A1"
+};
+var TaskList = ({
+  items,
+  onTaskClick,
+  statusConfig,
+  emptyMessage = "No tasks"
+}) => {
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsx3("div", { className: "task-list__empty", "data-testid": "task-list-empty", children: emptyMessage });
+  }
+  return /* @__PURE__ */ jsx3("div", { className: "task-list", "data-testid": "task-list", children: items.map((item) => {
+    const cfg = statusConfig?.[item.status];
+    return /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        type: "button",
+        className: "task-list__row",
+        "data-testid": `task-${item.id}`,
+        onClick: () => onTaskClick?.(item),
+        children: [
+          item.type && /* @__PURE__ */ jsx3("span", { className: "task-list__type", children: TYPE_ICONS2[item.type] || item.type }),
+          item.priority && /* @__PURE__ */ jsx3(
+            "span",
+            {
+              className: "task-list__priority",
+              style: { backgroundColor: PRIORITY_COLORS[item.priority] },
+              title: item.priority
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { className: "task-list__id", children: item.id }),
+          /* @__PURE__ */ jsx3("span", { className: "task-list__title", children: item.title }),
+          cfg && /* @__PURE__ */ jsx3(
+            "span",
+            {
+              className: "task-list__badge",
+              style: { backgroundColor: cfg.color + "22", color: cfg.color, borderColor: cfg.color + "44" },
+              children: cfg.label
+            }
+          )
+        ]
+      },
+      item.id
+    );
+  }) });
+};
+
+// src/DetailPanel/DetailPanel.tsx
+import { useEffect, useRef } from "react";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var DetailPanel = ({
+  isOpen,
+  onClose,
+  title,
+  subtitle,
+  fields,
+  children
+}) => {
+  const panelRef = useRef(null);
+  useEffect(() => {
+    if (!isOpen) return;
+    const handleEsc = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("keydown", handleEsc);
+    return () => document.removeEventListener("keydown", handleEsc);
+  }, [isOpen, onClose]);
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsx4("div", { className: "detail-overlay", onClick: onClose, role: "presentation", children: /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      ref: panelRef,
+      className: "detail-panel",
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-label": title,
+      onClick: (e) => e.stopPropagation(),
+      children: [
+        /* @__PURE__ */ jsxs4("div", { className: "detail-panel__header", children: [
+          /* @__PURE__ */ jsxs4("div", { className: "detail-panel__titles", children: [
+            subtitle && /* @__PURE__ */ jsx4("span", { className: "detail-panel__subtitle", children: subtitle }),
+            /* @__PURE__ */ jsx4("h2", { className: "detail-panel__title", children: title })
+          ] }),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              className: "detail-panel__close",
+              onClick: onClose,
+              "aria-label": "Close",
+              children: /* @__PURE__ */ jsx4("svg", { width: "18", height: "18", viewBox: "0 0 20 20", fill: "none", children: /* @__PURE__ */ jsx4("path", { d: "M15 5L5 15M5 5L15 15", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) })
+            }
+          )
+        ] }),
+        fields && fields.length > 0 && /* @__PURE__ */ jsx4("div", { className: "detail-panel__fields", children: fields.map((f, i) => /* @__PURE__ */ jsxs4("div", { className: "detail-panel__field", children: [
+          /* @__PURE__ */ jsx4("span", { className: "detail-panel__field-label", children: f.label }),
+          /* @__PURE__ */ jsx4(
+            "span",
+            {
+              className: "detail-panel__field-value",
+              style: f.color ? { color: f.color } : void 0,
+              children: f.value
+            }
+          )
+        ] }, i)) }),
+        /* @__PURE__ */ jsx4("div", { className: "detail-panel__body", children })
+      ]
+    }
+  ) });
+};
+
+// src/Dashboard/DashboardGrid.tsx
+import { useRef as useRef2, useCallback, useState, useMemo, useEffect as useEffect2 } from "react";
+import { Fragment, jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var HOLD_DELAY = 200;
+function calculateHoverIndex(widgets, draggedId, mouseX, mouseY, gridElement) {
+  const items = Array.from(gridElement.querySelectorAll(".dashboard-grid__item:not(.dashboard-grid__item--dragging)"));
+  if (items.length === 0) return 0;
+  let closestIndex = 0;
+  let closestDistance = Infinity;
+  items.forEach((item, index) => {
+    const rect = item.getBoundingClientRect();
+    const centerX2 = rect.left + rect.width / 2;
+    const centerY2 = rect.top + rect.height / 2;
+    const distance = Math.sqrt(
+      Math.pow(mouseX - centerX2, 2) + Math.pow(mouseY - centerY2, 2)
+    );
+    if (distance < closestDistance) {
+      closestDistance = distance;
+      closestIndex = index;
+    }
+  });
+  const closestRect = items[closestIndex].getBoundingClientRect();
+  const centerX = closestRect.left + closestRect.width / 2;
+  const centerY = closestRect.top + closestRect.height / 2;
+  if (mouseX > centerX || mouseY > centerY) {
+    return Math.min(closestIndex + 1, items.length);
+  }
+  return closestIndex;
+}
+var DashboardGrid = ({
+  widgets,
+  columns,
+  onMove,
+  onMoveToIndex,
+  onWidgetContextMenu,
+  renderWidget,
+  className
+}) => {
+  const gridRef = useRef2(null);
+  const holdTimerRef = useRef2(null);
+  const dragHandlersRef = useRef2(null);
+  const [dragState, setDragState] = useState(null);
+  useEffect2(() => {
+    return () => {
+      if (holdTimerRef.current) clearTimeout(holdTimerRef.current);
+      if (dragHandlersRef.current) dragHandlersRef.current.cleanup();
+    };
+  }, []);
+  const displayWidgets = useMemo(() => {
+    if (!dragState) return widgets;
+    const draggedWidget = widgets.find((w) => w.id === dragState.widgetId);
+    if (!draggedWidget) return widgets;
+    const otherWidgets = widgets.filter((w) => w.id !== dragState.widgetId);
+    const reordered = [
+      ...otherWidgets.slice(0, dragState.hoverIndex),
+      draggedWidget,
+      ...otherWidgets.slice(dragState.hoverIndex)
+    ];
+    return reordered;
+  }, [widgets, dragState]);
+  const handleDragStart = useCallback(
+    (widgetId, colSpan, locked) => (e) => {
+      if (locked || !onMoveToIndex) return;
+      e.preventDefault();
+      e.stopPropagation();
+      const item = e.currentTarget.closest(".dashboard-grid__item");
+      if (!item) return;
+      const rect = item.getBoundingClientRect();
+      const offsetX = e.clientX - rect.left;
+      const offsetY = e.clientY - rect.top;
+      const startX = e.clientX;
+      const startY = e.clientY;
+      if (holdTimerRef.current) {
+        clearTimeout(holdTimerRef.current);
+      }
+      if (dragHandlersRef.current) {
+        dragHandlersRef.current.cleanup();
+      }
+      let isHolding = true;
+      let isDragging = false;
+      const handleMove = (moveEvent) => {
+        if (!isHolding && !isDragging) return;
+        if (isHolding) {
+          const dx = Math.abs(moveEvent.clientX - startX);
+          const dy = Math.abs(moveEvent.clientY - startY);
+          if (dx > 5 || dy > 5) {
+            cleanup();
+            return;
+          }
+        }
+        if (!isDragging) return;
+        moveEvent.preventDefault();
+        const grid = gridRef.current;
+        if (!grid) return;
+        const hoverIndex = calculateHoverIndex(
+          widgets,
+          widgetId,
+          moveEvent.clientX,
+          moveEvent.clientY,
+          grid
+        );
+        setDragState((prev) => {
+          if (!prev) return null;
+          return {
+            ...prev,
+            currentX: moveEvent.clientX,
+            currentY: moveEvent.clientY,
+            hoverIndex
+          };
+        });
+      };
+      const handleUp = (upEvent) => {
+        upEvent.preventDefault();
+        upEvent.stopPropagation();
+        if (isDragging) {
+          const grid = gridRef.current;
+          if (grid) {
+            const finalIndex = calculateHoverIndex(
+              widgets,
+              widgetId,
+              upEvent.clientX,
+              upEvent.clientY,
+              grid
+            );
+            if (onMoveToIndex) {
+              onMoveToIndex(widgetId, finalIndex);
+            }
+          }
+        }
+        cleanup();
+      };
+      const cleanup = () => {
+        isHolding = false;
+        if (holdTimerRef.current) {
+          clearTimeout(holdTimerRef.current);
+          holdTimerRef.current = null;
+        }
+        document.removeEventListener("mousemove", handleMove);
+        document.removeEventListener("mouseup", handleUp);
+        if (isDragging) {
+          item.classList.remove("dashboard-grid__item--dragging");
+          isDragging = false;
+          setTimeout(() => {
+            setDragState(null);
+          }, 0);
+        }
+        dragHandlersRef.current = null;
+      };
+      dragHandlersRef.current = { cleanup };
+      holdTimerRef.current = setTimeout(() => {
+        if (!isHolding) return;
+        isHolding = false;
+        isDragging = true;
+        holdTimerRef.current = null;
+        item.classList.add("dashboard-grid__item--dragging");
+        const initialIndex = widgets.findIndex((w) => w.id === widgetId);
+        setDragState({
+          widgetId,
+          startX,
+          startY,
+          currentX: startX,
+          currentY: startY,
+          offsetX,
+          offsetY,
+          hoverIndex: initialIndex
+        });
+      }, HOLD_DELAY);
+      document.addEventListener("mousemove", handleMove);
+      document.addEventListener("mouseup", handleUp);
+    },
+    [onMoveToIndex, columns, widgets]
+  );
+  const draggingWidget = dragState ? widgets.find((w) => w.id === dragState.widgetId) : null;
+  return /* @__PURE__ */ jsxs5(Fragment, { children: [
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        ref: gridRef,
+        className: `dashboard-grid ${className || ""}`,
+        "data-testid": "dashboard-grid",
+        children: displayWidgets.map((widget) => {
+          const clampedSpan = Math.min(widget.colSpan, columns);
+          const isDragging = dragState?.widgetId === widget.id;
+          return /* @__PURE__ */ jsxs5(
+            "div",
+            {
+              className: `dashboard-grid__item${widget.collapsed ? " dashboard-grid__item--collapsed" : ""}${isDragging ? " dashboard-grid__item--dragging" : ""}`,
+              "data-testid": `widget-${widget.id}`,
+              onContextMenu: onWidgetContextMenu ? (e) => onWidgetContextMenu(widget.id, e) : void 0,
+              style: {
+                gridColumn: `span ${clampedSpan}`
+              },
+              children: [
+                /* @__PURE__ */ jsx5(
+                  "div",
+                  {
+                    className: "dashboard-grid__drag-handle",
+                    onMouseDown: handleDragStart(widget.id, clampedSpan, widget.locked),
+                    style: { cursor: widget.locked ? "default" : "grab" }
+                  }
+                ),
+                renderWidget(widget)
+              ]
+            },
+            widget.id
+          );
+        })
+      }
+    ),
+    dragState && draggingWidget && /* @__PURE__ */ jsx5(
+      "div",
+      {
+        className: "dashboard-grid__ghost",
+        style: {
+          position: "fixed",
+          left: dragState.currentX - dragState.offsetX,
+          top: dragState.currentY - dragState.offsetY,
+          width: `${100 / columns * Math.min(draggingWidget.colSpan, columns)}%`,
+          maxWidth: "600px",
+          pointerEvents: "none",
+          zIndex: 9999
+        },
+        children: renderWidget(draggingWidget)
+      }
+    )
+  ] });
+};
+
+// src/Dashboard/ResizeHandle.tsx
+import { useCallback as useCallback2, useRef as useRef3 } from "react";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var ResizeHandle = ({
+  onResize,
+  minColSpan = 2,
+  minRowSpan = 1
+}) => {
+  const startRef = useRef3({ x: 0, y: 0 });
+  const handlePointerDown = useCallback2(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      startRef.current = { x: e.clientX, y: e.clientY };
+      const target = e.currentTarget;
+      target.setPointerCapture(e.pointerId);
+      const handleUp = (upEvent) => {
+        target.releasePointerCapture(upEvent.pointerId);
+        target.removeEventListener("pointerup", handleUp);
+        const dx = upEvent.clientX - startRef.current.x;
+        const dy = upEvent.clientY - startRef.current.y;
+        const colDelta = Math.round(dx / 100);
+        const rowDelta = Math.round(dy / 80);
+        const newColSpan = Math.max(minColSpan, minColSpan + colDelta);
+        const newRowSpan = Math.max(minRowSpan, minRowSpan + rowDelta);
+        onResize(newColSpan, newRowSpan);
+      };
+      target.addEventListener("pointerup", handleUp);
+    },
+    [onResize, minColSpan, minRowSpan]
+  );
+  return /* @__PURE__ */ jsx6(
+    "div",
+    {
+      className: "resize-handle",
+      "data-testid": "resize-handle",
+      onPointerDown: handlePointerDown,
+      "aria-label": "Resize widget",
+      role: "separator"
+    }
+  );
+};
+
+// src/Dashboard/useGridDrag.ts
+import { useCallback as useCallback3, useRef as useRef4, useState as useState2 } from "react";
+var useGridDrag = ({
+  gridRef,
+  columns = 12,
+  onDrop
+}) => {
+  const [isDragging, setIsDragging] = useState2(false);
+  const startPos = useRef4({ x: 0, y: 0 });
+  const snapToGrid = useCallback3(
+    (clientX, clientY) => {
+      const grid = gridRef.current;
+      if (!grid) return { col: 1, row: 1 };
+      const rect = grid.getBoundingClientRect();
+      const colWidth = rect.width / columns;
+      const rowHeight = 80;
+      const relX = clientX - rect.left;
+      const relY = clientY - rect.top;
+      const col = Math.max(1, Math.min(columns, Math.ceil(relX / colWidth)));
+      const row = Math.max(1, Math.ceil(relY / rowHeight));
+      return { col, row };
+    },
+    [gridRef, columns]
+  );
+  const handlePointerDown = useCallback3(
+    (e) => {
+      e.preventDefault();
+      setIsDragging(true);
+      startPos.current = { x: e.clientX, y: e.clientY };
+      const target = e.currentTarget;
+      target.setPointerCapture(e.pointerId);
+      const handleMove = (_moveEvent) => {
+      };
+      const handleUp = (upEvent) => {
+        setIsDragging(false);
+        target.releasePointerCapture(upEvent.pointerId);
+        target.removeEventListener("pointermove", handleMove);
+        target.removeEventListener("pointerup", handleUp);
+        const { col, row } = snapToGrid(upEvent.clientX, upEvent.clientY);
+        onDrop(col, row);
+      };
+      target.addEventListener("pointermove", handleMove);
+      target.addEventListener("pointerup", handleUp);
+    },
+    [snapToGrid, onDrop]
+  );
+  return { isDragging, handlePointerDown };
+};
+
+// src/Dashboard/WidgetContextMenu.tsx
+import { useEffect as useEffect3, useRef as useRef5 } from "react";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function getColSpanOptions(columns) {
+  if (columns <= 1) return [1];
+  const opts = [];
+  for (let i = 1; i <= columns; i++) {
+    if (columns % i === 0 || i === columns) opts.push(i);
+  }
+  if (!opts.includes(columns)) opts.push(columns);
+  return opts;
+}
+var WidgetContextMenu = ({
+  x,
+  y,
+  widgetId,
+  columns,
+  currentColSpan,
+  isLocked = false,
+  onColSpanChange,
+  onHide,
+  onLock,
+  onClose
+}) => {
+  const menuRef = useRef5(null);
+  useEffect3(() => {
+    const handleClick = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("mousedown", handleClick);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleClick);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [onClose]);
+  useEffect3(() => {
+    if (!menuRef.current) return;
+    const rect = menuRef.current.getBoundingClientRect();
+    const maxX = window.innerWidth - rect.width - 8;
+    const maxY = window.innerHeight - rect.height - 8;
+    if (x > maxX) menuRef.current.style.left = `${maxX}px`;
+    if (y > maxY) menuRef.current.style.top = `${maxY}px`;
+  }, [x, y]);
+  const spanOptions = getColSpanOptions(columns);
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      ref: menuRef,
+      className: "widget-ctx",
+      style: { left: x, top: y },
+      "data-testid": "widget-context-menu",
+      children: [
+        /* @__PURE__ */ jsxs6("div", { className: "widget-ctx__group", children: [
+          /* @__PURE__ */ jsx7("span", { className: "widget-ctx__label", children: "Width" }),
+          spanOptions.map((span) => /* @__PURE__ */ jsx7(
+            "button",
+            {
+              type: "button",
+              className: `widget-ctx__item${span === currentColSpan ? " widget-ctx__item--active" : ""}`,
+              onClick: () => {
+                onColSpanChange(widgetId, span);
+                onClose();
+              },
+              children: span === columns ? "Full width" : `${span} col${span > 1 ? "s" : ""}`
+            },
+            span
+          ))
+        ] }),
+        /* @__PURE__ */ jsx7("div", { className: "widget-ctx__divider" }),
+        /* @__PURE__ */ jsx7(
+          "button",
+          {
+            type: "button",
+            className: "widget-ctx__item",
+            onClick: () => {
+              onHide(widgetId);
+              onClose();
+            },
+            children: "Hide Widget"
+          }
+        ),
+        /* @__PURE__ */ jsx7(
+          "button",
+          {
+            type: "button",
+            className: "widget-ctx__item",
+            onClick: () => {
+              onLock(widgetId);
+              onClose();
+            },
+            children: isLocked ? "Unlock Widget" : "Lock Widget"
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/ProjectsSidebar/ProjectsSidebar.tsx
+import { useState as useState4, useCallback as useCallback5, useMemo as useMemo2 } from "react";
+import { BoxIcon as BoxIcon2 } from "@orchestra-mcp/icons";
+import { EmptyState } from "@orchestra-mcp/ui";
+
+// src/ProjectsSidebar/ProjectItem.tsx
+import { useCallback as useCallback4, useEffect as useEffect4, useLayoutEffect, useRef as useRef6, useState as useState3 } from "react";
+import { BoxIcon } from "@orchestra-mcp/icons";
+import { Fragment as Fragment2, jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var PROJECT_ICONS = [
+  "bx-folder",
+  "bx-code-alt",
+  "bx-bug",
+  "bx-rocket",
+  "bx-terminal",
+  "bx-git-branch",
+  "bx-wrench",
+  "bx-book-open",
+  "bx-data",
+  "bx-shield",
+  "bx-world",
+  "bx-star",
+  "bx-bolt",
+  "bx-layer",
+  "bx-cube"
+];
+var PROJECT_COLORS = [
+  "#6366f1",
+  "#8b5cf6",
+  "#a855f7",
+  "#ec4899",
+  "#ef4444",
+  "#f59e0b",
+  "#22c55e",
+  "#14b8a6",
+  "#06b6d4",
+  "#3b82f6"
+];
+var SWIPE_THRESHOLD = 70;
+var HOLD_DELAY2 = 200;
+var LONG_PRESS_DELAY = 500;
+function ProjectItem({
+  slug,
+  name,
+  status,
+  taskCount,
+  completionPercent,
+  active = false,
+  pinned = false,
+  icon,
+  color,
+  selected = false,
+  selectionMode = false,
+  onSelect,
+  onDelete,
+  onPin,
+  onRename,
+  onIconChange,
+  onColorChange,
+  onUpdateKey,
+  onToggleSelect,
+  onIconClick
+}) {
+  const [offsetX, setOffsetX] = useState3(0);
+  const swipingRef = useRef6(false);
+  const startX = useRef6(0);
+  const holdTimer = useRef6(null);
+  const longPressTimer = useRef6(null);
+  const longPressFired = useRef6(false);
+  const cleanup = useCallback4(() => {
+    if (holdTimer.current) {
+      clearTimeout(holdTimer.current);
+      holdTimer.current = null;
+    }
+    if (longPressTimer.current) {
+      clearTimeout(longPressTimer.current);
+      longPressTimer.current = null;
+    }
+    document.removeEventListener("pointermove", handleDocMove);
+    document.removeEventListener("pointerup", handleDocUp);
+  }, []);
+  const handleDocMove = useCallback4((e) => {
+    const dx = e.clientX - startX.current;
+    swipingRef.current = true;
+    if (longPressTimer.current && Math.abs(dx) > 8) {
+      clearTimeout(longPressTimer.current);
+      longPressTimer.current = null;
+    }
+    const max = SWIPE_THRESHOLD + 20;
+    const clamped2 = Math.max(-max, Math.min(max, dx));
+    if (clamped2 > 0 && !onPin) return;
+    if (clamped2 < 0 && !onDelete) return;
+    setOffsetX(clamped2);
+  }, [onPin, onDelete]);
+  const handleDocUp = useCallback4(() => {
+    cleanup();
+    setOffsetX((prev) => {
+      if (prev >= SWIPE_THRESHOLD && onPin) onPin(slug);
+      else if (prev <= -SWIPE_THRESHOLD && onDelete) setConfirmDelete(true);
+      return 0;
+    });
+    setTimeout(() => {
+      swipingRef.current = false;
+    }, 50);
+  }, [slug, onPin, onDelete, cleanup]);
+  const onPointerDown = useCallback4((e) => {
+    if (e.button !== 0) return;
+    startX.current = e.clientX;
+    longPressFired.current = false;
+    cleanup();
+    if (onToggleSelect) {
+      longPressTimer.current = setTimeout(() => {
+        longPressFired.current = true;
+        onToggleSelect(slug);
+      }, LONG_PRESS_DELAY);
+    }
+    holdTimer.current = setTimeout(() => {
+      document.addEventListener("pointermove", handleDocMove);
+      document.addEventListener("pointerup", handleDocUp, { once: true });
+    }, HOLD_DELAY2);
+  }, [cleanup, handleDocMove, handleDocUp, onToggleSelect, slug]);
+  const onPointerUp = useCallback4(() => {
+    if (holdTimer.current) {
+      clearTimeout(holdTimer.current);
+      holdTimer.current = null;
+    }
+    if (longPressTimer.current) {
+      clearTimeout(longPressTimer.current);
+      longPressTimer.current = null;
+    }
+  }, []);
+  const handleClick = useCallback4(() => {
+    if (swipingRef.current || longPressFired.current) return;
+    if (selectionMode && onToggleSelect) {
+      onToggleSelect(slug);
+      return;
+    }
+    onSelect(slug);
+  }, [slug, onSelect, selectionMode, onToggleSelect]);
+  const [menuPos, setMenuPos] = useState3(null);
+  const [hoveredSub, setHoveredSub] = useState3(null);
+  const menuRef = useRef6(null);
+  const openMenu = useCallback4((x, y) => {
+    setMenuPos({ x, y });
+    setHoveredSub(null);
+  }, []);
+  const closeMenu = useCallback4(() => {
+    setMenuPos(null);
+    setHoveredSub(null);
+  }, []);
+  const handleContextMenu = useCallback4((e) => {
+    e.preventDefault();
+    openMenu(e.clientX, e.clientY);
+  }, [openMenu]);
+  const clamped = useRef6(false);
+  useLayoutEffect(() => {
+    if (!menuPos) {
+      clamped.current = false;
+      return;
+    }
+    if (clamped.current || !menuRef.current) return;
+    clamped.current = true;
+    const rect = menuRef.current.getBoundingClientRect();
+    let { x, y } = menuPos;
+    if (y + rect.height > window.innerHeight - 8) {
+      y = Math.max(8, window.innerHeight - rect.height - 8);
+    }
+    if (x + rect.width > window.innerWidth - 8) {
+      x = Math.max(8, window.innerWidth - rect.width - 8);
+    }
+    if (x !== menuPos.x || y !== menuPos.y) {
+      setMenuPos({ x, y });
+    }
+  });
+  useEffect4(() => {
+    if (!menuPos) return;
+    const handler = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        closeMenu();
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, [menuPos, closeMenu]);
+  const [confirmDelete, setConfirmDelete] = useState3(false);
+  const dialogRef = useRef6(null);
+  useEffect4(() => {
+    const el = dialogRef.current;
+    if (!el) return;
+    if (confirmDelete) el.showModal();
+    else if (el.open) el.close();
+  }, [confirmDelete]);
+  const handleConfirmYes = useCallback4((e) => {
+    e.stopPropagation();
+    setConfirmDelete(false);
+    onDelete?.(slug);
+  }, [slug, onDelete]);
+  const handleConfirmNo = useCallback4((e) => {
+    e.stopPropagation();
+    setConfirmDelete(false);
+  }, []);
+  const handleDialogBackdrop = useCallback4((e) => {
+    if (e.target === e.currentTarget) setConfirmDelete(false);
+  }, []);
+  const [renaming, setRenaming] = useState3(false);
+  const [renameValue, setRenameValue] = useState3(name);
+  const renameInputRef = useRef6(null);
+  useEffect4(() => {
+    if (renaming) {
+      setRenameValue(name);
+      setTimeout(() => renameInputRef.current?.select(), 30);
+    }
+  }, [renaming, name]);
+  const commitRename = useCallback4(() => {
+    const v = renameValue.trim();
+    if (v && v !== name) onRename?.(slug, v);
+    setRenaming(false);
+  }, [slug, renameValue, name, onRename]);
+  const handleRenameKey = useCallback4((e) => {
+    if (e.key === "Enter") commitRename();
+    if (e.key === "Escape") setRenaming(false);
+  }, [commitRename]);
+  const [copied, setCopied] = useState3(false);
+  const showPin = offsetX > 10;
+  const showDelete = offsetX < -10;
+  return /* @__PURE__ */ jsxs7("div", { className: `project-item__wrapper${active ? " project-item__wrapper--active" : ""}${selected ? " project-item__wrapper--selected" : ""}`, children: [
+    /* @__PURE__ */ jsxs7("div", { className: `project-item__action project-item__action--pin${showPin ? " project-item__action--visible" : ""}`, children: [
+      /* @__PURE__ */ jsx8(BoxIcon, { name: pinned ? "bxs-pin" : "bx-pin", size: 18 }),
+      /* @__PURE__ */ jsx8("span", { children: pinned ? "Unpin" : "Pin" })
+    ] }),
+    /* @__PURE__ */ jsxs7("div", { className: `project-item__action project-item__action--delete${showDelete ? " project-item__action--visible" : ""}`, children: [
+      /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-trash", size: 18 }),
+      /* @__PURE__ */ jsx8("span", { children: "Delete" })
+    ] }),
+    /* @__PURE__ */ jsxs7(
+      "button",
+      {
+        className: `project-item${active ? " project-item--active" : ""}${selected ? " project-item--selected" : ""}`,
+        onClick: handleClick,
+        onContextMenu: handleContextMenu,
+        type: "button",
+        onPointerDown,
+        onPointerUp,
+        style: {
+          transform: offsetX ? `translateX(${offsetX}px)` : void 0,
+          transition: offsetX ? "none" : "transform 0.25s ease"
+        },
+        children: [
+          selectionMode && /* @__PURE__ */ jsx8("span", { className: `project-item__checkbox${selected ? " project-item__checkbox--checked" : ""}`, children: selected && /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-check", size: 14 }) }),
+          /* @__PURE__ */ jsx8(
+            "span",
+            {
+              className: "project-item__icon",
+              style: color ? { color } : void 0,
+              onClick: (e) => {
+                if (onIconClick) {
+                  e.stopPropagation();
+                  onIconClick(slug);
+                }
+              },
+              children: /* @__PURE__ */ jsx8(BoxIcon, { name: icon || "bx-folder", size: 18 })
+            }
+          ),
+          /* @__PURE__ */ jsxs7("div", { className: "project-item__body", children: [
+            renaming ? /* @__PURE__ */ jsx8(
+              "input",
+              {
+                ref: renameInputRef,
+                className: "project-item__rename-input",
+                value: renameValue,
+                onChange: (e) => setRenameValue(e.target.value),
+                onBlur: commitRename,
+                onKeyDown: handleRenameKey,
+                onClick: (e) => e.stopPropagation()
+              }
+            ) : /* @__PURE__ */ jsx8("span", { className: "project-item__title", children: name }),
+            !renaming && /* @__PURE__ */ jsxs7("span", { className: "project-item__preview", children: [
+              taskCount,
+              " tasks \xB7 ",
+              Math.round(completionPercent),
+              "%"
+            ] }),
+            /* @__PURE__ */ jsx8("span", { className: "project-item__status", children: status })
+          ] }),
+          /* @__PURE__ */ jsx8("div", { className: "project-item__meta", children: pinned && /* @__PURE__ */ jsx8("span", { className: "project-item__pin-badge", "aria-label": "Pinned", children: /* @__PURE__ */ jsx8(BoxIcon, { name: "bxs-pin", size: 12 }) }) })
+        ]
+      }
+    ),
+    menuPos && /* @__PURE__ */ jsx8(
+      "div",
+      {
+        ref: menuRef,
+        className: "project-item__menu",
+        style: { top: menuPos.y, left: menuPos.x },
+        children: selectionMode ? /* @__PURE__ */ jsxs7(Fragment2, { children: [
+          onPin && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            closeMenu();
+            onPin(slug);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: pinned ? "bxs-pin" : "bx-pin", size: 15 }),
+            " ",
+            pinned ? "Unpin" : "Pin"
+          ] }),
+          onDelete && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item project-item__menu-item--danger", onClick: () => {
+            closeMenu();
+            setConfirmDelete(true);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-trash", size: 15 }),
+            " Delete"
+          ] })
+        ] }) : /* @__PURE__ */ jsxs7(Fragment2, { children: [
+          onToggleSelect && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            closeMenu();
+            onToggleSelect(slug);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-select-multiple", size: 15 }),
+            " Select"
+          ] }),
+          onRename && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            closeMenu();
+            setRenaming(true);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-edit-alt", size: 15 }),
+            " Rename"
+          ] }),
+          /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            navigator.clipboard.writeText(slug);
+            setCopied(true);
+            setTimeout(() => {
+              setCopied(false);
+              closeMenu();
+            }, 600);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: copied ? "bx-check" : "bx-copy-alt", size: 15 }),
+            " ",
+            copied ? "Copied!" : "Copy Slug"
+          ] }),
+          onPin && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            closeMenu();
+            onPin(slug);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: pinned ? "bxs-pin" : "bx-pin", size: 15 }),
+            " ",
+            pinned ? "Unpin" : "Pin"
+          ] }),
+          onIconChange && /* @__PURE__ */ jsxs7(
+            "div",
+            {
+              className: "project-item__menu-parent",
+              onMouseEnter: () => setHoveredSub("icon"),
+              onMouseLeave: () => setHoveredSub(null),
+              children: [
+                /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", type: "button", children: [
+                  /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-palette", size: 15 }),
+                  " Set Icon",
+                  /* @__PURE__ */ jsx8("span", { className: "project-item__menu-chevron", children: /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-chevron-right", size: 14 }) })
+                ] }),
+                hoveredSub === "icon" && /* @__PURE__ */ jsx8("div", { className: "project-item__submenu", children: /* @__PURE__ */ jsx8("div", { className: "project-item__icon-grid", children: PROJECT_ICONS.map((ic) => /* @__PURE__ */ jsx8(
+                  "button",
+                  {
+                    className: `project-item__icon-pick${ic === icon ? " project-item__icon-pick--active" : ""}`,
+                    onClick: () => {
+                      onIconChange(slug, ic);
+                      closeMenu();
+                    },
+                    type: "button",
+                    title: ic.replace("bx-", ""),
+                    children: /* @__PURE__ */ jsx8(BoxIcon, { name: ic, size: 16 })
+                  },
+                  ic
+                )) }) })
+              ]
+            }
+          ),
+          onColorChange && /* @__PURE__ */ jsxs7(
+            "div",
+            {
+              className: "project-item__menu-parent",
+              onMouseEnter: () => setHoveredSub("color"),
+              onMouseLeave: () => setHoveredSub(null),
+              children: [
+                /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", type: "button", children: [
+                  /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-color", size: 15 }),
+                  " Set Color",
+                  /* @__PURE__ */ jsx8("span", { className: "project-item__menu-chevron", children: /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-chevron-right", size: 14 }) })
+                ] }),
+                hoveredSub === "color" && /* @__PURE__ */ jsx8("div", { className: "project-item__submenu", children: /* @__PURE__ */ jsx8("div", { className: "project-item__color-grid", children: PROJECT_COLORS.map((c) => /* @__PURE__ */ jsx8(
+                  "button",
+                  {
+                    className: `project-item__color-pick${c === color ? " project-item__color-pick--active" : ""}`,
+                    style: { background: c },
+                    onClick: () => {
+                      onColorChange(slug, c);
+                      closeMenu();
+                    },
+                    type: "button"
+                  },
+                  c
+                )) }) })
+              ]
+            }
+          ),
+          onUpdateKey && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item", onClick: () => {
+            closeMenu();
+            onUpdateKey(slug);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-key", size: 15 }),
+            " Update Key"
+          ] }),
+          onDelete && /* @__PURE__ */ jsxs7("button", { className: "project-item__menu-item project-item__menu-item--danger", onClick: () => {
+            closeMenu();
+            setConfirmDelete(true);
+          }, type: "button", children: [
+            /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-trash", size: 15 }),
+            " Delete"
+          ] })
+        ] })
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      "dialog",
+      {
+        ref: dialogRef,
+        className: "project-item__dialog",
+        onClick: handleDialogBackdrop,
+        children: /* @__PURE__ */ jsxs7("div", { className: "project-item__dialog-inner", children: [
+          /* @__PURE__ */ jsx8("div", { className: "project-item__dialog-icon", children: /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-trash", size: 28 }) }),
+          /* @__PURE__ */ jsx8("h3", { className: "project-item__dialog-title", children: "Delete project?" }),
+          /* @__PURE__ */ jsxs7("p", { className: "project-item__dialog-body", children: [
+            '"',
+            /* @__PURE__ */ jsx8("strong", { children: name }),
+            '" will be permanently deleted and cannot be recovered.'
+          ] }),
+          /* @__PURE__ */ jsxs7("div", { className: "project-item__dialog-actions", children: [
+            /* @__PURE__ */ jsx8(
+              "button",
+              {
+                className: "project-item__dialog-btn project-item__dialog-btn--cancel",
+                onClick: handleConfirmNo,
+                type: "button",
+                children: "Cancel"
+              }
+            ),
+            /* @__PURE__ */ jsxs7(
+              "button",
+              {
+                className: "project-item__dialog-btn project-item__dialog-btn--delete",
+                onClick: handleConfirmYes,
+                type: "button",
+                children: [
+                  /* @__PURE__ */ jsx8(BoxIcon, { name: "bx-trash", size: 14 }),
+                  "Delete"
+                ]
+              }
+            )
+          ] })
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/ProjectsSidebar/ProjectsSidebar.tsx
+import { jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+var ProjectsSidebar = ({
+  projects,
+  activeProject,
+  onProjectClick,
+  onCreateProject,
+  onDeleteProject,
+  onPinProject,
+  onRenameProject,
+  onIconChange,
+  onColorChange,
+  onUpdateKey,
+  onIconClick,
+  loading = false,
+  searchQuery: controlledQuery,
+  onSearchChange: controlledOnChange
+}) => {
+  const [internalQuery, setInternalQuery] = useState4("");
+  const query = controlledQuery ?? internalQuery;
+  const setQuery = controlledOnChange ?? setInternalQuery;
+  const [selectedSlugs, setSelectedSlugs] = useState4(/* @__PURE__ */ new Set());
+  const selectionMode = selectedSlugs.size > 0;
+  const handleToggleSelect = useCallback5((slug) => {
+    setSelectedSlugs((prev) => {
+      const next = new Set(prev);
+      if (next.has(slug)) next.delete(slug);
+      else next.add(slug);
+      return next;
+    });
+  }, []);
+  const sorted = useMemo2(() => {
+    const filtered = query.trim() ? projects.filter(
+      (p) => p.name.toLowerCase().includes(query.toLowerCase()) || p.slug.toLowerCase().includes(query.toLowerCase())
+    ) : projects;
+    return [...filtered].sort((a, b) => {
+      if (a.pinned && !b.pinned) return -1;
+      if (!a.pinned && b.pinned) return 1;
+      return a.name.localeCompare(b.name);
+    });
+  }, [projects, query]);
+  const handleSearch = useCallback5((e) => {
+    setQuery(e.target.value);
+  }, [setQuery]);
+  return /* @__PURE__ */ jsxs8("aside", { className: "projects-sidebar", "data-testid": "projects-sidebar", children: [
+    /* @__PURE__ */ jsxs8("div", { className: "projects-sidebar__header", children: [
+      /* @__PURE__ */ jsx9("h2", { className: "projects-sidebar__title", children: "Projects" }),
+      onCreateProject && /* @__PURE__ */ jsx9(
+        "button",
+        {
+          className: "projects-sidebar__new-btn",
+          "data-testid": "create-project-btn",
+          onClick: onCreateProject,
+          "aria-label": "Create project",
+          children: /* @__PURE__ */ jsx9(BoxIcon2, { name: "bx-plus", size: 18 })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs8("div", { className: "projects-sidebar__search", children: [
+      /* @__PURE__ */ jsx9("span", { className: "projects-sidebar__search-icon", children: /* @__PURE__ */ jsx9(BoxIcon2, { name: "bx-search", size: 16 }) }),
+      /* @__PURE__ */ jsx9(
+        "input",
+        {
+          className: "projects-sidebar__search-input",
+          type: "text",
+          placeholder: "Search projects...",
+          value: query,
+          onChange: handleSearch
+        }
+      )
+    ] }),
+    loading ? /* @__PURE__ */ jsx9("div", { className: "projects-sidebar__loading", "aria-label": "Loading projects", children: /* @__PURE__ */ jsx9(BoxIcon2, { name: "bx-loader-alt", size: 20, className: "projects-sidebar__spinner" }) }) : sorted.length > 0 ? /* @__PURE__ */ jsx9("div", { className: "projects-sidebar__list", "data-testid": "projects-list", children: sorted.map((project) => /* @__PURE__ */ jsx9(
+      ProjectItem,
+      {
+        slug: project.slug,
+        name: project.name,
+        status: project.status,
+        taskCount: project.taskCount,
+        completionPercent: project.completionPercent,
+        active: activeProject === project.slug,
+        pinned: project.pinned,
+        icon: project.icon,
+        color: project.color,
+        selected: selectedSlugs.has(project.slug),
+        selectionMode,
+        onSelect: onProjectClick,
+        onDelete: onDeleteProject,
+        onPin: onPinProject,
+        onRename: onRenameProject,
+        onIconChange,
+        onColorChange,
+        onUpdateKey,
+        onToggleSelect: handleToggleSelect,
+        onIconClick
+      },
+      project.slug
+    )) }) : /* @__PURE__ */ jsx9(
+      EmptyState,
+      {
+        icon: /* @__PURE__ */ jsx9(BoxIcon2, { name: "bx-grid-alt", size: 40 }),
+        title: query.trim() ? "No matching projects" : "No projects yet",
+        description: query.trim() ? "Try a different search term" : "Create a project to get started"
+      }
+    )
+  ] });
+};
+
+// src/stores/useDashboardStore.ts
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+var defaultLayout = [
+  { id: "w-project-status", type: "project-status", col: 1, row: 1, colSpan: 1, rowSpan: 1, collapsed: false, hidden: false },
+  { id: "w-backlog-tree", type: "backlog-tree", col: 1, row: 2, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-task-distribution", type: "task-distribution", col: 1, row: 3, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-progress-distribution", type: "progress-distribution", col: 1, row: 4, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-active-tasks", type: "active-tasks", col: 1, row: 5, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-recent-activity", type: "recent-activity", col: 1, row: 6, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-sprint-progress", type: "sprint-progress", col: 1, row: 7, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-team-workload", type: "team-workload", col: 1, row: 8, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-session-metrics", type: "session-metrics", col: 1, row: 9, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true },
+  { id: "w-feature-adoption", type: "feature-adoption", col: 1, row: 10, colSpan: 1, rowSpan: 1, collapsed: false, hidden: true }
+];
+function updateWidget(state, slug, widgetId, updater) {
+  const current = state.layouts[slug] ?? defaultLayout;
+  return {
+    layouts: {
+      ...state.layouts,
+      [slug]: current.map((w) => w.id === widgetId ? updater(w) : w)
+    }
+  };
+}
+var useDashboardStore = create()(
+  persist(
+    (set, get) => ({
+      layouts: {},
+      columns: {},
+      activeProject: null,
+      setActiveProject: (slug) => set({ activeProject: slug }),
+      getLayout: (slug) => get().layouts[slug] ?? defaultLayout,
+      updateLayout: (slug, layouts) => set((s) => ({ layouts: { ...s.layouts, [slug]: layouts } })),
+      moveWidget: (slug, widgetId, col, row) => set((s) => {
+        const current = s.layouts[slug] ?? defaultLayout;
+        const widgetIndex = current.findIndex((w) => w.id === widgetId);
+        if (widgetIndex === -1) return s;
+        const widget = current[widgetIndex];
+        const updatedWidget = { ...widget, col, row };
+        const withoutWidget = current.filter((w) => w.id !== widgetId);
+        let targetIndex = 0;
+        for (let i = 0; i < withoutWidget.length; i++) {
+          const w = withoutWidget[i];
+          if (w.row < row || w.row === row && w.col < col) {
+            targetIndex = i + 1;
+          }
+        }
+        const reordered = [
+          ...withoutWidget.slice(0, targetIndex),
+          updatedWidget,
+          ...withoutWidget.slice(targetIndex)
+        ];
+        return { layouts: { ...s.layouts, [slug]: reordered } };
+      }),
+      moveWidgetToIndex: (slug, widgetId, newIndex) => set((s) => {
+        const current = s.layouts[slug] ?? defaultLayout;
+        const widget = current.find((w) => w.id === widgetId);
+        if (!widget) return s;
+        const withoutWidget = current.filter((w) => w.id !== widgetId);
+        const targetIndex = Math.max(0, Math.min(withoutWidget.length, newIndex));
+        const reordered = [
+          ...withoutWidget.slice(0, targetIndex),
+          widget,
+          ...withoutWidget.slice(targetIndex)
+        ];
+        return { layouts: { ...s.layouts, [slug]: reordered } };
+      }),
+      resizeWidget: (slug, widgetId, colSpan, rowSpan) => set((s) => updateWidget(s, slug, widgetId, (w) => ({ ...w, colSpan, rowSpan }))),
+      toggleCollapse: (slug, widgetId) => set((s) => updateWidget(s, slug, widgetId, (w) => ({ ...w, collapsed: !w.collapsed }))),
+      toggleHidden: (slug, widgetId) => set((s) => updateWidget(s, slug, widgetId, (w) => ({ ...w, hidden: !w.hidden }))),
+      toggleLocked: (slug, widgetId) => set((s) => updateWidget(s, slug, widgetId, (w) => ({ ...w, locked: !w.locked }))),
+      setWidgetColSpan: (slug, widgetId, colSpan) => set((s) => updateWidget(s, slug, widgetId, (w) => ({ ...w, colSpan, col: 1 }))),
+      addWidget: (slug, type) => set((s) => {
+        const current = s.layouts[slug] ?? defaultLayout;
+        const id = `w-${type}-${Date.now()}`;
+        return {
+          layouts: {
+            ...s.layouts,
+            [slug]: [...current, { id, type, col: 1, row: 99, colSpan: 1, rowSpan: 1, collapsed: false }]
+          }
+        };
+      }),
+      removeWidget: (slug, widgetId) => set((s) => {
+        const current = s.layouts[slug] ?? defaultLayout;
+        return { layouts: { ...s.layouts, [slug]: current.filter((w) => w.id !== widgetId) } };
+      }),
+      resetLayout: (slug) => set((s) => ({ layouts: { ...s.layouts, [slug]: defaultLayout } })),
+      getColumns: (slug) => get().columns[slug] ?? 1,
+      setColumns: (slug, cols) => set((s) => ({ columns: { ...s.columns, [slug]: cols } }))
+    }),
+    {
+      name: "orchestra-dashboard-layout",
+      version: 8,
+      migrate: () => ({ layouts: {}, columns: {}, activeProject: null })
+    }
+  )
+);
+
+// src/stores/useIntegrationStore.ts
+import { create as create2 } from "zustand";
+import { persist as persist2 } from "zustand/middleware";
+var emptyConnection = {
+  connected: false,
+  user: null,
+  lastSync: null
+};
+var useIntegrationStore = create2()(
+  persist2(
+    (set) => ({
+      jira: { ...emptyConnection },
+      linear: { ...emptyConnection },
+      github: { ...emptyConnection },
+      syncInProgress: false,
+      setConnected: (provider, user) => set((s) => ({
+        [provider]: { ...s[provider], connected: true, user }
+      })),
+      disconnect: (provider) => set(() => ({
+        [provider]: { ...emptyConnection }
+      })),
+      setSyncInProgress: (value) => set({ syncInProgress: value }),
+      updateLastSync: (provider, time) => set((s) => ({
+        [provider]: { ...s[provider], lastSync: time }
+      }))
+    }),
+    { name: "orchestra-integrations" }
+  )
+);
+
+// src/stores/useTaskDetailStore.ts
+import { create as create3 } from "zustand";
+var useTaskDetailStore = create3((set) => ({
+  selectedTask: null,
+  selectTask: (task) => set({ selectedTask: task }),
+  clearSelection: () => set({ selectedTask: null })
+}));
+
+// src/ProjectDashboard/ProjectDashboard.tsx
+import { useState as useState18, useCallback as useCallback19 } from "react";
+
+// src/ProjectDashboard/DashboardHeader.tsx
+import { BoxIcon as BoxIcon3 } from "@orchestra-mcp/icons";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var DashboardHeader = ({
+  name,
+  onRefresh,
+  onSettingsToggle
+}) => {
+  return /* @__PURE__ */ jsxs9("div", { className: "dashboard-header", "data-testid": "dashboard-header", children: [
+    /* @__PURE__ */ jsx10("h2", { className: "dashboard-header__title", children: name }),
+    /* @__PURE__ */ jsx10("div", { className: "dashboard-header__spacer" }),
+    onRefresh && /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "dashboard-header__btn",
+        onClick: onRefresh,
+        "aria-label": "Refresh",
+        type: "button",
+        children: /* @__PURE__ */ jsx10(BoxIcon3, { name: "bx-refresh", size: 16 })
+      }
+    ),
+    /* @__PURE__ */ jsx10(
+      "button",
+      {
+        className: "dashboard-header__btn",
+        onClick: onSettingsToggle,
+        "aria-label": "Settings",
+        type: "button",
+        children: /* @__PURE__ */ jsx10(BoxIcon3, { name: "bx-slider-alt", size: 16 })
+      }
+    )
+  ] });
+};
+
+// src/ProjectDashboard/DashboardSettings.tsx
+import { useEffect as useEffect5, useRef as useRef7 } from "react";
+import { BoxIcon as BoxIcon4 } from "@orchestra-mcp/icons";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+var COLUMN_OPTIONS = [1, 2, 4, 6, 12];
+var DashboardSettings = ({
+  x,
+  y,
+  columns,
+  onColumnsChange,
+  widgets,
+  onWidgetToggle,
+  onClose
+}) => {
+  const menuRef = useRef7(null);
+  useEffect5(() => {
+    const handleClick = (e) => {
+      if (menuRef.current && !menuRef.current.contains(e.target)) {
+        onClose();
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("mousedown", handleClick);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleClick);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [onClose]);
+  useEffect5(() => {
+    if (!menuRef.current) return;
+    const rect = menuRef.current.getBoundingClientRect();
+    const maxX = window.innerWidth - rect.width - 8;
+    const maxY = window.innerHeight - rect.height - 8;
+    if (x > maxX) menuRef.current.style.left = `${maxX}px`;
+    if (y > maxY) menuRef.current.style.top = `${maxY}px`;
+  }, [x, y]);
+  return /* @__PURE__ */ jsxs10(
+    "div",
+    {
+      ref: menuRef,
+      className: "dashboard-settings",
+      style: { left: x, top: y },
+      "data-testid": "dashboard-settings",
+      children: [
+        /* @__PURE__ */ jsxs10("div", { className: "dashboard-settings__section", children: [
+          /* @__PURE__ */ jsx11("label", { className: "dashboard-settings__label", children: "Columns per row" }),
+          /* @__PURE__ */ jsx11("div", { className: "dashboard-settings__chips", children: COLUMN_OPTIONS.map((n) => /* @__PURE__ */ jsx11(
+            "button",
+            {
+              type: "button",
+              className: `dashboard-settings__chip${columns === n ? " dashboard-settings__chip--active" : ""}`,
+              onClick: () => onColumnsChange(n),
+              children: n
+            },
+            n
+          )) })
+        ] }),
+        /* @__PURE__ */ jsx11("div", { className: "dashboard-settings__divider" }),
+        /* @__PURE__ */ jsxs10("div", { className: "dashboard-settings__section", children: [
+          /* @__PURE__ */ jsx11("label", { className: "dashboard-settings__label", children: "Widgets" }),
+          /* @__PURE__ */ jsx11("ul", { className: "dashboard-settings__widget-list", children: widgets.map((w) => /* @__PURE__ */ jsxs10("li", { className: "dashboard-settings__widget-row", children: [
+            /* @__PURE__ */ jsx11("span", { className: "dashboard-settings__widget-name", children: w.title }),
+            /* @__PURE__ */ jsx11(
+              "button",
+              {
+                type: "button",
+                className: `dashboard-settings__toggle${w.hidden ? "" : " dashboard-settings__toggle--on"}`,
+                onClick: () => onWidgetToggle(w.id),
+                "aria-label": w.hidden ? `Show ${w.title}` : `Hide ${w.title}`,
+                children: /* @__PURE__ */ jsx11(BoxIcon4, { name: w.hidden ? "bx-hide" : "bx-show", size: 14 })
+              }
+            )
+          ] }, w.id)) })
+        ] })
+      ]
+    }
+  );
+};
+
+// src/TaskDetailPanel/TaskDetailPanel.tsx
+import { useMemo as useMemo4, useCallback as useCallback17, useState as useState16 } from "react";
+
+// src/StatusBadge/StatusBadge.tsx
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+var STATUS_COLORS = {
+  backlog: "#6b7280",
+  todo: "#3b82f6",
+  "in-progress": "#8b5cf6",
+  blocked: "#ef4444",
+  "ready-for-testing": "#f59e0b",
+  "in-testing": "#f97316",
+  "ready-for-docs": "#06b6d4",
+  "in-docs": "#0ea5e9",
+  documented: "#14b8a6",
+  "in-review": "#a855f7",
+  done: "#22c55e",
+  rejected: "#ef4444",
+  cancelled: "#6b7280"
+};
+var STATUS_LABELS = {
+  backlog: "Backlog",
+  todo: "To Do",
+  "in-progress": "In Progress",
+  blocked: "Blocked",
+  "ready-for-testing": "Ready for Testing",
+  "in-testing": "In Testing",
+  "ready-for-docs": "Ready for Docs",
+  "in-docs": "In Docs",
+  documented: "Documented",
+  "in-review": "In Review",
+  done: "Done",
+  rejected: "Rejected",
+  cancelled: "Cancelled"
+};
+function StatusBadge({ status, variant = "dot", size = "sm" }) {
+  const color = STATUS_COLORS[status] ?? "#6b7280";
+  const label = STATUS_LABELS[status] ?? status;
+  if (variant === "dot") {
+    return /* @__PURE__ */ jsx12(
+      "span",
+      {
+        className: `status-badge status-badge--dot status-badge--${size}`,
+        style: { backgroundColor: color },
+        title: label,
+        "aria-label": label
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs11(
+    "span",
+    {
+      className: `status-badge status-badge--pill status-badge--${size}`,
+      style: { backgroundColor: `${color}20`, color },
+      title: label,
+      children: [
+        /* @__PURE__ */ jsx12("span", { className: "status-badge__dot", style: { backgroundColor: color } }),
+        label
+      ]
+    }
+  );
+}
+
+// src/PriorityIcon/PriorityIcon.tsx
+import { BoxIcon as BoxIcon5 } from "@orchestra-mcp/icons";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var PRIORITY_CONFIG = {
+  critical: { icon: "bxs-chevrons-up", color: "#ef4444", label: "Critical" },
+  high: { icon: "bx-chevron-up", color: "#f97316", label: "High" },
+  medium: { icon: "bx-minus", color: "#eab308", label: "Medium" },
+  low: { icon: "bx-chevron-down", color: "#6b7280", label: "Low" }
+};
+function PriorityIcon({ priority, size = 14 }) {
+  const config = PRIORITY_CONFIG[priority];
+  if (!config) return null;
+  return /* @__PURE__ */ jsx13(
+    "span",
+    {
+      className: "priority-icon",
+      style: { color: config.color },
+      title: config.label,
+      "aria-label": `${config.label} priority`,
+      children: /* @__PURE__ */ jsx13(BoxIcon5, { name: config.icon, size })
+    }
+  );
+}
+
+// src/InlineEdit/InlineEdit.tsx
+import { useState as useState5, useRef as useRef8, useEffect as useEffect6, useCallback as useCallback6 } from "react";
+import { jsx as jsx14, jsxs as jsxs12 } from "react/jsx-runtime";
+function EditableText({ value, onSave, saving, className, tag: Tag = "span" }) {
+  const [editing, setEditing] = useState5(false);
+  const [draft, setDraft] = useState5(value);
+  const inputRef = useRef8(null);
+  useEffect6(() => {
+    setDraft(value);
+  }, [value]);
+  useEffect6(() => {
+    if (editing) inputRef.current?.focus();
+  }, [editing]);
+  const save = useCallback6(() => {
+    setEditing(false);
+    if (draft.trim() && draft !== value) onSave(draft.trim());
+    else setDraft(value);
+  }, [draft, value, onSave]);
+  const handleKeyDown = useCallback6((e) => {
+    if (e.key === "Enter") save();
+    if (e.key === "Escape") {
+      setDraft(value);
+      setEditing(false);
+    }
+  }, [save, value]);
+  if (editing) {
+    return /* @__PURE__ */ jsx14(
+      "input",
+      {
+        ref: inputRef,
+        className: `inline-edit__input ${className ?? ""}`,
+        value: draft,
+        onChange: (e) => setDraft(e.target.value),
+        onBlur: save,
+        onKeyDown: handleKeyDown
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs12(
+    Tag,
+    {
+      className: `inline-edit__text ${className ?? ""}${saving ? " inline-edit--saving" : ""}`,
+      onClick: () => setEditing(true),
+      role: "button",
+      tabIndex: 0,
+      children: [
+        value || /* @__PURE__ */ jsx14("span", { className: "inline-edit__placeholder", children: "Click to edit..." }),
+        saving && /* @__PURE__ */ jsx14("span", { className: "inline-edit__indicator" })
+      ]
+    }
+  );
+}
+function EditableTextarea({ value, onSave, saving, placeholder }) {
+  const [editing, setEditing] = useState5(false);
+  const [draft, setDraft] = useState5(value);
+  const textareaRef = useRef8(null);
+  useEffect6(() => {
+    setDraft(value);
+  }, [value]);
+  useEffect6(() => {
+    if (editing && textareaRef.current) {
+      textareaRef.current.focus();
+      textareaRef.current.style.height = "auto";
+      textareaRef.current.style.height = `${textareaRef.current.scrollHeight}px`;
+    }
+  }, [editing]);
+  const save = useCallback6(() => {
+    setEditing(false);
+    if (draft !== value) onSave(draft);
+    else setDraft(value);
+  }, [draft, value, onSave]);
+  const handleKeyDown = useCallback6((e) => {
+    if (e.key === "Escape") {
+      setDraft(value);
+      setEditing(false);
+    }
+  }, [value]);
+  const handleInput = useCallback6((e) => {
+    setDraft(e.target.value);
+    e.target.style.height = "auto";
+    e.target.style.height = `${e.target.scrollHeight}px`;
+  }, []);
+  if (editing) {
+    return /* @__PURE__ */ jsx14(
+      "textarea",
+      {
+        ref: textareaRef,
+        className: "inline-edit__textarea",
+        value: draft,
+        onChange: handleInput,
+        onBlur: save,
+        onKeyDown: handleKeyDown
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs12(
+    "p",
+    {
+      className: `inline-edit__text inline-edit__text--multiline${saving ? " inline-edit--saving" : ""}`,
+      onClick: () => setEditing(true),
+      role: "button",
+      tabIndex: 0,
+      children: [
+        value || /* @__PURE__ */ jsx14("span", { className: "inline-edit__placeholder", children: placeholder ?? "Click to add..." }),
+        saving && /* @__PURE__ */ jsx14("span", { className: "inline-edit__indicator" })
+      ]
+    }
+  );
+}
+function EditableSelect({ value, options, onSave, saving, placeholder }) {
+  const [editing, setEditing] = useState5(false);
+  const selectRef = useRef8(null);
+  useEffect6(() => {
+    if (editing) selectRef.current?.focus();
+  }, [editing]);
+  const handleChange = useCallback6((e) => {
+    setEditing(false);
+    if (e.target.value !== value) onSave(e.target.value);
+  }, [value, onSave]);
+  const label = options.find((o) => o.value === value)?.label ?? value;
+  if (editing) {
+    return /* @__PURE__ */ jsxs12(
+      "select",
+      {
+        ref: selectRef,
+        className: "inline-edit__select",
+        value,
+        onChange: handleChange,
+        onBlur: () => setEditing(false),
+        children: [
+          placeholder && /* @__PURE__ */ jsx14("option", { value: "", children: placeholder }),
+          options.map((o) => /* @__PURE__ */ jsx14("option", { value: o.value, children: o.label }, o.value))
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs12(
+    "span",
+    {
+      className: `inline-edit__text${saving ? " inline-edit--saving" : ""}`,
+      onClick: () => setEditing(true),
+      role: "button",
+      tabIndex: 0,
+      children: [
+        label || placeholder || "\u2014",
+        saving && /* @__PURE__ */ jsx14("span", { className: "inline-edit__indicator" })
+      ]
+    }
+  );
+}
+
+// src/TaskDetailPanel/TaskDetailPanel.tsx
+import { MarkdownRenderer } from "@orchestra-mcp/editor";
+
+// src/hooks/useProjects.ts
+import { useState as useState6, useEffect as useEffect7, useCallback as useCallback7 } from "react";
+function useProjects() {
+  const [projects, setProjects] = useState6([]);
+  const [loading, setLoading] = useState6(true);
+  const [error, setError] = useState6(null);
+  const refresh = useCallback7(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await mcpCall("list_projects");
+      if (!data.projects || !Array.isArray(data.projects)) {
+        setProjects([]);
+        setLoading(false);
+        return;
+      }
+      const summaries = await Promise.all(
+        data.projects.map(async (p) => {
+          const displayName = p.project || p.name || p.slug;
+          try {
+            const wf = await mcpCall(
+              "get_workflow_status",
+              { project: p.slug }
+            );
+            return {
+              slug: p.slug,
+              name: displayName,
+              status: p.status ?? "active",
+              epicCount: 0,
+              taskCount: wf?.total ?? 0,
+              completionPercent: wf?.completion_pct ? parseFloat(wf.completion_pct) : 0,
+              integrations: []
+            };
+          } catch {
+            return {
+              slug: p.slug,
+              name: displayName,
+              status: p.status ?? "active",
+              epicCount: 0,
+              taskCount: 0,
+              completionPercent: 0,
+              integrations: []
+            };
+          }
+        })
+      );
+      setProjects(summaries);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load projects");
+    }
+    setLoading(false);
+  }, []);
+  useEffect7(() => {
+    refresh();
+  }, [refresh]);
+  const createProject = useCallback7(
+    async (name) => {
+      await mcpCall("create_project", { name });
+      await refresh();
+    },
+    [refresh]
+  );
+  return { projects, loading, error, refresh, createProject };
+}
+
+// src/hooks/useProjectTree.ts
+import { useState as useState7, useEffect as useEffect8, useCallback as useCallback8 } from "react";
+function mapTree(epics) {
+  return epics.map((e) => ({
+    id: e.id,
+    title: e.title,
+    type: "epic",
+    status: e.status,
+    priority: e.priority,
+    children: (e.stories ?? []).map((s) => ({
+      id: s.id,
+      title: s.title,
+      type: "story",
+      status: s.status,
+      priority: s.priority,
+      estimate: s.estimate,
+      children: (s.tasks ?? []).map((t) => ({
+        id: t.id,
+        title: t.title,
+        type: t.type || "task",
+        status: t.status,
+        priority: t.priority,
+        description: t.description,
+        labels: t.labels,
+        estimate: t.estimate,
+        assignedTo: t.assigned_to
+      }))
+    }))
+  }));
+}
+function useProjectTree(slug) {
+  const [tree, setTree] = useState7([]);
+  const [loading, setLoading] = useState7(false);
+  const [error, setError] = useState7(null);
+  const refresh = useCallback8(async () => {
+    if (!slug) {
+      setTree([]);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const raw = await mcpCall("get_project_tree", { project: slug });
+      setTree(Array.isArray(raw) ? mapTree(raw) : []);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load project tree");
+    }
+    setLoading(false);
+  }, [slug]);
+  useEffect8(() => {
+    refresh();
+  }, [refresh]);
+  return { tree, loading, error, refresh };
+}
+
+// src/hooks/useTaskActions.ts
+import { useState as useState8, useCallback as useCallback9 } from "react";
+function useTaskActions() {
+  const [actionState, setActionState] = useState8({});
+  const getState = (key) => actionState[key] ?? { loading: false, error: null };
+  const run = useCallback9(async (key, fn) => {
+    setActionState((prev) => ({ ...prev, [key]: { loading: true, error: null } }));
+    try {
+      await fn();
+      setActionState((prev) => ({ ...prev, [key]: { loading: false, error: null } }));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Action failed";
+      setActionState((prev) => ({ ...prev, [key]: { loading: false, error: message } }));
+    }
+  }, []);
+  const startTask = useCallback9(
+    (loc) => run("start", () => mcpCall("set_current_task", loc)),
+    [run]
+  );
+  const advanceTask = useCallback9(
+    (loc, evidence) => run("advance", () => mcpCall("advance_task", { ...loc, evidence })),
+    [run]
+  );
+  const blockTask = useCallback9(
+    (loc) => run("block", () => mcpCall("update_task", { ...loc, status: "blocked" })),
+    [run]
+  );
+  const assignTask = useCallback9(
+    (loc, assignee) => run("assign", () => mcpCall("assign_task", { ...loc, assignee })),
+    [run]
+  );
+  const completeTask = useCallback9(
+    (loc) => run("complete", () => mcpCall("complete_task", loc)),
+    [run]
+  );
+  return {
+    startTask,
+    advanceTask,
+    blockTask,
+    assignTask,
+    completeTask,
+    starting: getState("start"),
+    advancing: getState("advance"),
+    blocking: getState("block"),
+    assigning: getState("assign"),
+    completing: getState("complete")
+  };
+}
+
+// src/hooks/useTaskDetail.ts
+import { useState as useState9, useEffect as useEffect9, useCallback as useCallback10, useRef as useRef9 } from "react";
+function useTaskDetail(params) {
+  const [task, setTask] = useState9(null);
+  const [loading, setLoading] = useState9(false);
+  const [error, setError] = useState9(null);
+  const [isStale, setIsStale] = useState9(false);
+  const latestRef = useRef9(null);
+  const project = params?.project ?? null;
+  const epicId = params?.epicId ?? null;
+  const storyId = params?.storyId ?? null;
+  const taskId = params?.taskId ?? null;
+  const refresh = useCallback10(async () => {
+    if (!project || !epicId || !storyId || !taskId) {
+      setTask(null);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await mcpCall("get_task", {
+        project,
+        epic_id: epicId,
+        story_id: storyId,
+        task_id: taskId
+      });
+      setTask(result);
+      setIsStale(false);
+      latestRef.current = null;
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to load task");
+    }
+    setLoading(false);
+  }, [project, epicId, storyId, taskId]);
+  useEffect9(() => {
+    refresh();
+  }, [refresh]);
+  const checkForUpdates = useCallback10(async () => {
+    if (!project || !epicId || !storyId || !taskId || !task) return;
+    try {
+      const fresh = await mcpCall("get_task", {
+        project,
+        epic_id: epicId,
+        story_id: storyId,
+        task_id: taskId
+      });
+      if (fresh.updated_at !== task.updated_at) {
+        latestRef.current = fresh;
+        setIsStale(true);
+      }
+    } catch {
+    }
+  }, [project, epicId, storyId, taskId, task]);
+  const dismissStale = useCallback10(() => {
+    setIsStale(false);
+    latestRef.current = null;
+  }, []);
+  const acceptStale = useCallback10(() => {
+    if (latestRef.current) {
+      setTask(latestRef.current);
+      latestRef.current = null;
+    }
+    setIsStale(false);
+  }, []);
+  return {
+    task,
+    loading,
+    error,
+    refresh,
+    isStale,
+    checkForUpdates,
+    dismissStale,
+    acceptStale
+  };
+}
+
+// src/hooks/useFilteredTree.ts
+import { useMemo as useMemo3 } from "react";
+function useFilteredTree(tree, filters) {
+  return useMemo3(() => {
+    const hasFilters = filters.statuses.length > 0 || filters.priorities.length > 0 || filters.assignee !== "" || filters.searchQuery !== "";
+    if (!hasFilters) return tree;
+    return filterTree(tree, filters);
+  }, [tree, filters]);
+}
+function filterTree(nodes, filters) {
+  return nodes.reduce((acc, node) => {
+    if (node.type === "task" || node.type === "bug" || node.type === "hotfix") {
+      if (matchesFilters(node, filters)) acc.push(node);
+    } else {
+      const filteredChildren = filterTree(node.children ?? [], filters);
+      if (filteredChildren.length > 0) {
+        acc.push({ ...node, children: filteredChildren });
+      }
+    }
+    return acc;
+  }, []);
+}
+function matchesFilters(node, filters) {
+  if (filters.statuses.length > 0 && !filters.statuses.includes(node.status)) {
+    return false;
+  }
+  if (filters.priorities.length > 0 && node.priority && !filters.priorities.includes(node.priority)) {
+    return false;
+  }
+  if (filters.priorities.length > 0 && !node.priority) {
+    return false;
+  }
+  if (filters.assignee && node.assignedTo !== filters.assignee) {
+    return false;
+  }
+  if (filters.searchQuery) {
+    const query = filters.searchQuery.toLowerCase();
+    const titleMatch = node.title.toLowerCase().includes(query);
+    const descMatch = node.description?.toLowerCase().includes(query) ?? false;
+    if (!titleMatch && !descMatch) return false;
+  }
+  return true;
+}
+function collectMatchParentIds(tree, searchQuery) {
+  if (!searchQuery) return /* @__PURE__ */ new Set();
+  const ids = /* @__PURE__ */ new Set();
+  const query = searchQuery.toLowerCase();
+  function walk(nodes, parentIds) {
+    for (const node of nodes) {
+      const isLeaf = node.type === "task" || node.type === "bug" || node.type === "hotfix";
+      if (isLeaf) {
+        const matches = node.title.toLowerCase().includes(query) || (node.description?.toLowerCase().includes(query) ?? false);
+        if (matches) {
+          for (const id of parentIds) ids.add(id);
+        }
+      } else {
+        walk(node.children ?? [], [...parentIds, node.id]);
+      }
+    }
+  }
+  walk(tree, []);
+  return ids;
+}
+function extractAssignees(tree) {
+  const set = /* @__PURE__ */ new Set();
+  function walk(nodes) {
+    for (const n of nodes) {
+      if (n.assignedTo) set.add(n.assignedTo);
+      if (n.children) walk(n.children);
+    }
+  }
+  walk(tree);
+  return [...set].sort();
+}
+
+// src/hooks/useDebounce.ts
+import { useState as useState10, useEffect as useEffect10 } from "react";
+function useDebounce(value, delay) {
+  const [debounced, setDebounced] = useState10(value);
+  useEffect10(() => {
+    const timer = setTimeout(() => setDebounced(value), delay);
+    return () => clearTimeout(timer);
+  }, [value, delay]);
+  return debounced;
+}
+
+// src/hooks/useConnectionStatus.ts
+import { useState as useState11, useEffect as useEffect11, useRef as useRef10, useCallback as useCallback11 } from "react";
+var DEFAULT_WS_URL = "ws://127.0.0.1:8765";
+var RECONNECT_DELAY = 3e3;
+var MAX_RETRIES = 3;
+function useConnectionStatus(wsUrl) {
+  const url = wsUrl ?? DEFAULT_WS_URL;
+  const [status, setStatus] = useState11("reconnecting");
+  const [lastConnected, setLastConnected] = useState11(null);
+  const wsRef = useRef10(null);
+  const retriesRef = useRef10(0);
+  const timerRef = useRef10(null);
+  const mountedRef = useRef10(true);
+  const pausedRef = useRef10(false);
+  const cleanup = useCallback11(() => {
+    if (timerRef.current) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+    if (wsRef.current) {
+      wsRef.current.onopen = null;
+      wsRef.current.onclose = null;
+      wsRef.current.onerror = null;
+      wsRef.current.close();
+      wsRef.current = null;
+    }
+  }, []);
+  const connect = useCallback11(() => {
+    if (!mountedRef.current || pausedRef.current) return;
+    cleanup();
+    try {
+      const ws = new WebSocket(url);
+      wsRef.current = ws;
+      ws.onopen = () => {
+        if (!mountedRef.current) return;
+        retriesRef.current = 0;
+        setStatus("connected");
+        setLastConnected(/* @__PURE__ */ new Date());
+      };
+      ws.onclose = () => {
+        if (!mountedRef.current) return;
+        wsRef.current = null;
+        if (retriesRef.current >= MAX_RETRIES) {
+          setStatus("disconnected");
+          return;
+        }
+        retriesRef.current += 1;
+        setStatus("reconnecting");
+        timerRef.current = setTimeout(connect, RECONNECT_DELAY);
+      };
+      ws.onerror = () => {
+      };
+    } catch {
+      if (!mountedRef.current) return;
+      if (retriesRef.current >= MAX_RETRIES) {
+        setStatus("disconnected");
+        return;
+      }
+      retriesRef.current += 1;
+      setStatus("reconnecting");
+      timerRef.current = setTimeout(connect, RECONNECT_DELAY);
+    }
+  }, [url, cleanup]);
+  useEffect11(() => {
+    mountedRef.current = true;
+    connect();
+    const handleVisibility = () => {
+      if (document.hidden) {
+        pausedRef.current = true;
+        cleanup();
+      } else {
+        pausedRef.current = false;
+        retriesRef.current = 0;
+        setStatus("reconnecting");
+        connect();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    return () => {
+      mountedRef.current = false;
+      document.removeEventListener("visibilitychange", handleVisibility);
+      cleanup();
+    };
+  }, [connect, cleanup]);
+  return { status, lastConnected };
+}
+
+// src/hooks/useOptimisticTaskActions.ts
+import { useState as useState12, useCallback as useCallback12, useRef as useRef11 } from "react";
+var ADVANCE_MAP = {
+  "in-progress": "ready-for-testing",
+  "ready-for-testing": "in-testing",
+  "in-testing": "ready-for-docs",
+  "ready-for-docs": "in-docs",
+  "in-docs": "documented",
+  "documented": "in-review",
+  "in-review": "done"
+};
+function predictStatus(action, currentStatus) {
+  switch (action) {
+    case "start":
+      return "in-progress";
+    case "advance":
+      return ADVANCE_MAP[currentStatus] ?? null;
+    case "block":
+      return "blocked";
+    case "complete":
+      return "done";
+    default:
+      return null;
+  }
+}
+function useOptimisticTaskActions(options = {}) {
+  const [pendingTasks, setPendingTasks] = useState12(/* @__PURE__ */ new Set());
+  const optionsRef = useRef11(options);
+  optionsRef.current = options;
+  const addPending = useCallback12((taskId) => {
+    setPendingTasks((prev) => {
+      const next = new Set(prev);
+      next.add(taskId);
+      return next;
+    });
+  }, []);
+  const removePending = useCallback12((taskId) => {
+    setPendingTasks((prev) => {
+      const next = new Set(prev);
+      next.delete(taskId);
+      return next;
+    });
+  }, []);
+  const runOptimistic = useCallback12(
+    async (action, currentStatus, loc, mcpFn) => {
+      const taskId = loc.task_id;
+      const predicted = predictStatus(action, currentStatus);
+      if (predicted) {
+        addPending(taskId);
+        optionsRef.current.onOptimisticUpdate?.(taskId, predicted);
+      }
+      try {
+        await mcpFn();
+        optionsRef.current.onSettled?.(taskId);
+      } catch {
+        if (predicted) {
+          optionsRef.current.onRevert?.(taskId, currentStatus);
+        }
+        optionsRef.current.onSettled?.(taskId);
+      } finally {
+        removePending(taskId);
+      }
+    },
+    [addPending, removePending]
+  );
+  const startTask = useCallback12(
+    (loc, currentStatus) => runOptimistic(
+      "start",
+      currentStatus,
+      loc,
+      () => mcpCall("set_current_task", loc)
+    ),
+    [runOptimistic]
+  );
+  const advanceTask = useCallback12(
+    (loc, currentStatus, evidence) => runOptimistic(
+      "advance",
+      currentStatus,
+      loc,
+      () => mcpCall("advance_task", { ...loc, evidence })
+    ),
+    [runOptimistic]
+  );
+  const blockTask = useCallback12(
+    (loc, currentStatus) => runOptimistic(
+      "block",
+      currentStatus,
+      loc,
+      () => mcpCall("update_task", { ...loc, status: "blocked" })
+    ),
+    [runOptimistic]
+  );
+  const completeTask = useCallback12(
+    (loc, currentStatus) => runOptimistic(
+      "complete",
+      currentStatus,
+      loc,
+      () => mcpCall("complete_task", loc)
+    ),
+    [runOptimistic]
+  );
+  return {
+    startTask,
+    advanceTask,
+    blockTask,
+    completeTask,
+    pendingTasks
+  };
+}
+
+// src/LabelsSection/LabelsSection.tsx
+import { useState as useState13, useCallback as useCallback13, useRef as useRef12 } from "react";
+import { jsx as jsx15, jsxs as jsxs13 } from "react/jsx-runtime";
+function LabelsSection({ labels, project, epicId, storyId, taskId, onUpdate }) {
+  const [adding, setAdding] = useState13(false);
+  const [removingLabel, setRemovingLabel] = useState13(null);
+  const inputRef = useRef12(null);
+  const removeLabel = useCallback13(async (label) => {
+    setRemovingLabel(label);
+    try {
+      await mcpCall("remove_labels", {
+        project,
+        epic_id: epicId,
+        story_id: storyId,
+        task_id: taskId,
+        labels: [label]
+      });
+      onUpdate?.();
+    } catch {
+    }
+    setRemovingLabel(null);
+  }, [project, epicId, storyId, taskId, onUpdate]);
+  const addLabel = useCallback13(async (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      setAdding(false);
+      return;
+    }
+    try {
+      await mcpCall("add_labels", {
+        project,
+        epic_id: epicId,
+        story_id: storyId,
+        task_id: taskId,
+        labels: [trimmed]
+      });
+      onUpdate?.();
+    } catch {
+    }
+    setAdding(false);
+  }, [project, epicId, storyId, taskId, onUpdate]);
+  const handleKeyDown = useCallback13((e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      addLabel(e.currentTarget.value);
+    } else if (e.key === "Escape") {
+      setAdding(false);
+    }
+  }, [addLabel]);
+  const handleBlur = useCallback13((e) => {
+    const value = e.currentTarget.value.trim();
+    if (value) {
+      addLabel(value);
+    } else {
+      setAdding(false);
+    }
+  }, [addLabel]);
+  const handleAddClick = useCallback13(() => {
+    setAdding(true);
+    setTimeout(() => inputRef.current?.focus(), 0);
+  }, []);
+  return /* @__PURE__ */ jsxs13("section", { className: "labels-section", children: [
+    /* @__PURE__ */ jsx15("h3", { className: "task-detail__section-title", children: "Labels" }),
+    /* @__PURE__ */ jsxs13("div", { className: "labels-section__list", children: [
+      labels.length === 0 && !adding && /* @__PURE__ */ jsxs13("span", { className: "labels-section__empty", children: [
+        "No labels",
+        /* @__PURE__ */ jsx15(
+          "button",
+          {
+            className: "labels-section__add",
+            onClick: handleAddClick,
+            "aria-label": "Add label",
+            children: "+"
+          }
+        )
+      ] }),
+      labels.map((label) => /* @__PURE__ */ jsxs13(
+        "span",
+        {
+          className: `labels-section__pill${removingLabel === label ? " labels-section__pill--removing" : ""}`,
+          children: [
+            label,
+            /* @__PURE__ */ jsx15(
+              "button",
+              {
+                className: "labels-section__remove",
+                onClick: () => removeLabel(label),
+                "aria-label": `Remove ${label}`,
+                children: "\xD7"
+              }
+            )
+          ]
+        },
+        label
+      )),
+      labels.length > 0 && !adding && /* @__PURE__ */ jsx15(
+        "button",
+        {
+          className: "labels-section__add",
+          onClick: handleAddClick,
+          "aria-label": "Add label",
+          children: "+"
+        }
+      ),
+      adding && /* @__PURE__ */ jsx15(
+        "input",
+        {
+          ref: inputRef,
+          className: "labels-section__input",
+          type: "text",
+          placeholder: "Label...",
+          onKeyDown: handleKeyDown,
+          onBlur: handleBlur,
+          autoFocus: true
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/LinksSection/LinksSection.tsx
+import { useState as useState14, useCallback as useCallback14 } from "react";
+import { jsx as jsx16, jsxs as jsxs14 } from "react/jsx-runtime";
+var TYPE_ICONS3 = {
+  pr: "PR",
+  commit: "C",
+  issue: "#"
+};
+function typeIcon(type) {
+  return TYPE_ICONS3[type] ?? "\u{1F517}";
+}
+var LINK_TYPES = ["pr", "commit", "url", "issue"];
+function LinksSection({ links, project, epicId, storyId, taskId, onUpdate }) {
+  const [adding, setAdding] = useState14(false);
+  const [type, setType] = useState14("url");
+  const [url, setUrl] = useState14("");
+  const [title, setTitle] = useState14("");
+  const resetForm = useCallback14(() => {
+    setAdding(false);
+    setType("url");
+    setUrl("");
+    setTitle("");
+  }, []);
+  const handleSave = useCallback14(async () => {
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) return;
+    try {
+      await mcpCall("add_link", {
+        project,
+        epic_id: epicId,
+        story_id: storyId,
+        task_id: taskId,
+        type,
+        url: trimmedUrl,
+        title: title.trim() || void 0
+      });
+      onUpdate?.();
+    } catch {
+    }
+    resetForm();
+  }, [project, epicId, storyId, taskId, type, url, title, onUpdate, resetForm]);
+  const handleKeyDown = useCallback14((e) => {
+    if (e.key === "Escape") {
+      resetForm();
+    }
+  }, [resetForm]);
+  return /* @__PURE__ */ jsxs14("section", { className: "links-section", children: [
+    /* @__PURE__ */ jsx16("h3", { className: "task-detail__section-title", children: "Links" }),
+    links.length === 0 && !adding && /* @__PURE__ */ jsxs14("span", { className: "links-section__empty", children: [
+      "No links",
+      /* @__PURE__ */ jsx16(
+        "button",
+        {
+          className: "links-section__add",
+          onClick: () => setAdding(true),
+          "aria-label": "Add link",
+          children: "+"
+        }
+      )
+    ] }),
+    links.length > 0 && /* @__PURE__ */ jsx16("ul", { className: "links-section__list", children: links.map((link, i) => /* @__PURE__ */ jsxs14("li", { className: "links-section__item", children: [
+      /* @__PURE__ */ jsx16("span", { className: "links-section__type-badge", children: typeIcon(link.type) }),
+      /* @__PURE__ */ jsx16(
+        "a",
+        {
+          href: link.url,
+          target: "_blank",
+          rel: "noopener noreferrer",
+          className: "links-section__link",
+          children: link.title || link.url
+        }
+      )
+    ] }, i)) }),
+    adding ? /* @__PURE__ */ jsxs14("div", { className: "links-section__form", onKeyDown: handleKeyDown, children: [
+      /* @__PURE__ */ jsx16(
+        "select",
+        {
+          value: type,
+          onChange: (e) => setType(e.target.value),
+          "aria-label": "Link type",
+          children: LINK_TYPES.map((t) => /* @__PURE__ */ jsx16("option", { value: t, children: t }, t))
+        }
+      ),
+      /* @__PURE__ */ jsx16(
+        "input",
+        {
+          placeholder: "URL",
+          value: url,
+          onChange: (e) => setUrl(e.target.value),
+          autoFocus: true
+        }
+      ),
+      /* @__PURE__ */ jsx16(
+        "input",
+        {
+          placeholder: "Title (optional)",
+          value: title,
+          onChange: (e) => setTitle(e.target.value)
+        }
+      ),
+      /* @__PURE__ */ jsx16("button", { className: "links-section__save", onClick: handleSave, children: "Save" }),
+      /* @__PURE__ */ jsx16("button", { className: "links-section__cancel", onClick: resetForm, children: "Cancel" })
+    ] }) : links.length > 0 ? /* @__PURE__ */ jsx16(
+      "button",
+      {
+        className: "links-section__add",
+        onClick: () => setAdding(true),
+        "aria-label": "Add link",
+        children: "+ Add link"
+      }
+    ) : null
+  ] });
+}
+
+// src/TaskDetailPanel/StatusActions.tsx
+import { useCallback as useCallback15 } from "react";
+import { jsx as jsx17, jsxs as jsxs15 } from "react/jsx-runtime";
+var TERMINAL = /* @__PURE__ */ new Set(["done", "cancelled", "rejected"]);
+var STARTABLE = /* @__PURE__ */ new Set(["backlog", "todo", "blocked"]);
+var IN_PROGRESS = "in-progress";
+function StatusActions({ status, project, epicId, storyId, taskId, onAction }) {
+  const {
+    startTask,
+    advanceTask,
+    blockTask,
+    completeTask,
+    starting,
+    advancing,
+    blocking,
+    completing
+  } = useTaskActions();
+  const loc = {
+    project,
+    epic_id: epicId,
+    story_id: storyId,
+    task_id: taskId
+  };
+  const handleStart = useCallback15(async () => {
+    await startTask(loc);
+    onAction?.();
+  }, [startTask, loc, onAction]);
+  const handleAdvance = useCallback15(async () => {
+    await advanceTask(loc, void 0);
+    onAction?.();
+  }, [advanceTask, loc, onAction]);
+  const handleBlock = useCallback15(async () => {
+    await blockTask(loc);
+    onAction?.();
+  }, [blockTask, loc, onAction]);
+  const handleComplete = useCallback15(async () => {
+    await completeTask(loc);
+    onAction?.();
+  }, [completeTask, loc, onAction]);
+  const isTerminal = TERMINAL.has(status);
+  if (isTerminal) return null;
+  const showStart = STARTABLE.has(status);
+  const showAdvance = status === IN_PROGRESS || !TERMINAL.has(status) && !STARTABLE.has(status);
+  const showBlock = status === IN_PROGRESS;
+  const showComplete = status === IN_PROGRESS;
+  return /* @__PURE__ */ jsxs15("div", { className: "status-actions", children: [
+    showStart && /* @__PURE__ */ jsxs15(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Start task",
+        className: `status-actions__btn status-actions__btn--start${starting.loading ? " status-actions__btn--loading" : ""}`,
+        onClick: handleStart,
+        disabled: starting.loading,
+        children: [
+          starting.loading ? /* @__PURE__ */ jsx17("span", { className: "status-actions__spinner" }) : "\u25B6",
+          "Start"
+        ]
+      }
+    ),
+    showAdvance && /* @__PURE__ */ jsxs15(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Advance task",
+        className: `status-actions__btn status-actions__btn--advance${advancing.loading ? " status-actions__btn--loading" : ""}`,
+        onClick: handleAdvance,
+        disabled: advancing.loading,
+        children: [
+          advancing.loading ? /* @__PURE__ */ jsx17("span", { className: "status-actions__spinner" }) : "\u23E9",
+          "Advance"
+        ]
+      }
+    ),
+    showBlock && /* @__PURE__ */ jsxs15(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Block task",
+        className: `status-actions__btn status-actions__btn--block${blocking.loading ? " status-actions__btn--loading" : ""}`,
+        onClick: handleBlock,
+        disabled: blocking.loading,
+        children: [
+          blocking.loading ? /* @__PURE__ */ jsx17("span", { className: "status-actions__spinner" }) : "\u26D4",
+          "Block"
+        ]
+      }
+    ),
+    showComplete && /* @__PURE__ */ jsxs15(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Complete task",
+        className: `status-actions__btn status-actions__btn--complete${completing.loading ? " status-actions__btn--loading" : ""}`,
+        onClick: handleComplete,
+        disabled: completing.loading,
+        children: [
+          completing.loading ? /* @__PURE__ */ jsx17("span", { className: "status-actions__spinner" }) : "\u2714",
+          "Complete"
+        ]
+      }
+    )
+  ] });
+}
+
+// src/EvidenceLog/EvidenceLog.tsx
+import { useState as useState15, useCallback as useCallback16 } from "react";
+import { jsx as jsx18, jsxs as jsxs16 } from "react/jsx-runtime";
+var GATE_LABELS = {
+  testing: "Testing",
+  verification: "Verification",
+  documentation: "Documentation",
+  review: "Review"
+};
+var GATE_ICONS = {
+  testing: "\u{1F9EA}",
+  verification: "\u2705",
+  documentation: "\u{1F4DD}",
+  review: "\u{1F50D}"
+};
+var TRUNCATE_LENGTH = 120;
+function EvidenceLog({ evidence }) {
+  const [expanded, setExpanded] = useState15(() => /* @__PURE__ */ new Set());
+  const toggle = useCallback16((index) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(index)) {
+        next.delete(index);
+      } else {
+        next.add(index);
+      }
+      return next;
+    });
+  }, []);
+  if (evidence.length === 0) return null;
+  return /* @__PURE__ */ jsxs16("section", { className: "evidence-log", children: [
+    /* @__PURE__ */ jsx18("h3", { className: "task-detail__section-title", children: "Evidence Log" }),
+    /* @__PURE__ */ jsx18("div", { className: "evidence-log__timeline", children: evidence.map((entry, i) => {
+      const isExpanded = expanded.has(i);
+      const text = entry.description;
+      const isLong = text.length > TRUNCATE_LENGTH;
+      return /* @__PURE__ */ jsxs16("div", { className: "evidence-log__entry", children: [
+        /* @__PURE__ */ jsx18("div", { className: "evidence-log__marker" }),
+        /* @__PURE__ */ jsxs16("div", { className: "evidence-log__content", children: [
+          /* @__PURE__ */ jsxs16("div", { className: "evidence-log__header", children: [
+            /* @__PURE__ */ jsx18("span", { className: "evidence-log__icon", children: GATE_ICONS[entry.gate] ?? "\u{1F4CB}" }),
+            /* @__PURE__ */ jsx18("span", { className: "evidence-log__gate", children: GATE_LABELS[entry.gate] ?? entry.gate }),
+            /* @__PURE__ */ jsx18("span", { className: "evidence-log__time", children: new Date(entry.timestamp).toLocaleDateString() })
+          ] }),
+          /* @__PURE__ */ jsx18("p", { className: "evidence-log__text", children: isExpanded || !isLong ? text : text.slice(0, TRUNCATE_LENGTH) + "..." }),
+          isLong && /* @__PURE__ */ jsx18(
+            "button",
+            {
+              className: "evidence-log__toggle",
+              onClick: () => toggle(i),
+              children: isExpanded ? "Show less" : "Show more"
+            }
+          )
+        ] })
+      ] }, i);
+    }) })
+  ] });
+}
+
+// src/StaleNotification/StaleNotification.tsx
+import { jsx as jsx19, jsxs as jsxs17 } from "react/jsx-runtime";
+var StaleNotification = ({
+  onRefresh,
+  onDismiss
+}) => {
+  return /* @__PURE__ */ jsxs17("div", { className: "stale-notification", role: "status", "data-testid": "stale-notification", children: [
+    /* @__PURE__ */ jsx19("span", { className: "stale-notification__text", children: "Task updated externally" }),
+    /* @__PURE__ */ jsx19(
+      "button",
+      {
+        type: "button",
+        className: "stale-notification__btn stale-notification__btn--refresh",
+        onClick: onRefresh,
+        children: "Refresh"
+      }
+    ),
+    /* @__PURE__ */ jsx19(
+      "button",
+      {
+        type: "button",
+        className: "stale-notification__btn stale-notification__btn--dismiss",
+        onClick: onDismiss,
+        "aria-label": "Dismiss",
+        children: "\u2715"
+      }
+    )
+  ] });
+};
+
+// src/TaskDetailPanel/TaskDetailPanel.tsx
+import { Fragment as Fragment3, jsx as jsx20, jsxs as jsxs18 } from "react/jsx-runtime";
+var PRIORITY_OPTIONS = [
+  { value: "critical", label: "Critical" },
+  { value: "high", label: "High" },
+  { value: "medium", label: "Medium" },
+  { value: "low", label: "Low" }
+];
+function TaskDetailPanel({ isOpen, onClose, params }) {
+  const {
+    task,
+    loading,
+    error,
+    refresh,
+    isStale,
+    acceptStale,
+    dismissStale
+  } = useTaskDetail(isOpen ? params : null);
+  const [savingField, setSavingField] = useState16(null);
+  const [isEditingDescription, setIsEditingDescription] = useState16(false);
+  const saveField = useCallback17(async (field, value) => {
+    if (!params) return;
+    setSavingField(field);
+    try {
+      await mcpCall("update_task", {
+        project: params.project,
+        epic_id: params.epicId,
+        story_id: params.storyId,
+        task_id: params.taskId,
+        [field]: value
+      });
+      await refresh();
+    } catch {
+    }
+    setSavingField(null);
+  }, [params, refresh]);
+  const fields = useMemo4(() => {
+    if (!task) return [];
+    const result = [];
+    result.push({ label: "Status", value: task.status });
+    result.push({ label: "Type", value: task.type });
+    if (task.estimate !== void 0) result.push({ label: "Estimate", value: `${task.estimate} pts` });
+    return result;
+  }, [task]);
+  return /* @__PURE__ */ jsxs18(
+    DetailPanel,
+    {
+      isOpen,
+      onClose,
+      title: task?.title ?? "Loading...",
+      subtitle: task?.id,
+      fields,
+      children: [
+        loading && /* @__PURE__ */ jsx20("div", { className: "task-detail__loading", children: "Loading task..." }),
+        error && /* @__PURE__ */ jsx20("div", { className: "task-detail__error", children: error }),
+        task && params && /* @__PURE__ */ jsxs18(Fragment3, { children: [
+          isStale && /* @__PURE__ */ jsx20(StaleNotification, { onRefresh: acceptStale, onDismiss: dismissStale }),
+          /* @__PURE__ */ jsxs18("div", { className: "task-detail__status-row", children: [
+            /* @__PURE__ */ jsx20(StatusBadge, { status: task.status, variant: "pill", size: "md" }),
+            task.priority && /* @__PURE__ */ jsx20(PriorityIcon, { priority: task.priority, size: 16 })
+          ] }),
+          /* @__PURE__ */ jsx20(
+            StatusActions,
+            {
+              status: task.status,
+              project: params.project,
+              epicId: params.epicId,
+              storyId: params.storyId,
+              taskId: params.taskId,
+              onAction: refresh
+            }
+          ),
+          /* @__PURE__ */ jsxs18("section", { className: "task-detail__section", children: [
+            /* @__PURE__ */ jsx20("h3", { className: "task-detail__section-title", children: "Title" }),
+            /* @__PURE__ */ jsx20(
+              EditableText,
+              {
+                value: task.title,
+                onSave: (v) => saveField("title", v),
+                saving: savingField === "title",
+                tag: "h2",
+                className: "task-detail__editable-title"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs18("section", { className: "task-detail__section", children: [
+            /* @__PURE__ */ jsxs18("div", { className: "task-detail__section-header", children: [
+              /* @__PURE__ */ jsx20("h3", { className: "task-detail__section-title", children: "Description" }),
+              /* @__PURE__ */ jsx20(
+                "button",
+                {
+                  type: "button",
+                  className: "task-detail__edit-btn",
+                  onClick: () => setIsEditingDescription(!isEditingDescription),
+                  children: isEditingDescription ? "View" : "Edit"
+                }
+              )
+            ] }),
+            isEditingDescription ? /* @__PURE__ */ jsx20(
+              EditableTextarea,
+              {
+                value: task.description ?? "",
+                onSave: async (v) => {
+                  await saveField("description", v);
+                  setIsEditingDescription(false);
+                },
+                saving: savingField === "description",
+                placeholder: "Click to add description..."
+              }
+            ) : /* @__PURE__ */ jsx20("div", { className: "task-detail__markdown", children: task.description ? /* @__PURE__ */ jsx20(MarkdownRenderer, { content: task.description }) : /* @__PURE__ */ jsx20("p", { className: "task-detail__empty", onClick: () => setIsEditingDescription(true), children: "Click edit to add description..." }) })
+          ] }),
+          /* @__PURE__ */ jsxs18("section", { className: "task-detail__section", children: [
+            /* @__PURE__ */ jsx20("h3", { className: "task-detail__section-title", children: "Priority" }),
+            /* @__PURE__ */ jsx20(
+              EditableSelect,
+              {
+                value: task.priority ?? "",
+                options: PRIORITY_OPTIONS,
+                onSave: (v) => saveField("priority", v),
+                saving: savingField === "priority",
+                placeholder: "Select priority"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs18("section", { className: "task-detail__section", children: [
+            /* @__PURE__ */ jsx20("h3", { className: "task-detail__section-title", children: "Assignee" }),
+            /* @__PURE__ */ jsx20(
+              EditableText,
+              {
+                value: task.assigned_to ?? "",
+                onSave: (v) => saveField("assigned_to", v),
+                saving: savingField === "assigned_to"
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx20(
+            LabelsSection,
+            {
+              labels: task.labels ?? [],
+              project: params.project,
+              epicId: params.epicId,
+              storyId: params.storyId,
+              taskId: params.taskId,
+              onUpdate: refresh
+            }
+          ),
+          task.depends_on && task.depends_on.length > 0 && /* @__PURE__ */ jsxs18("section", { className: "task-detail__section", children: [
+            /* @__PURE__ */ jsx20("h3", { className: "task-detail__section-title", children: "Dependencies" }),
+            /* @__PURE__ */ jsx20("ul", { className: "task-detail__deps", children: task.depends_on.map((dep) => /* @__PURE__ */ jsx20("li", { className: "task-detail__dep", children: dep }, dep)) })
+          ] }),
+          /* @__PURE__ */ jsx20(
+            LinksSection,
+            {
+              links: task.links ?? [],
+              project: params.project,
+              epicId: params.epicId,
+              storyId: params.storyId,
+              taskId: params.taskId,
+              onUpdate: refresh
+            }
+          ),
+          (task.created_at || task.updated_at) && /* @__PURE__ */ jsxs18("section", { className: "task-detail__section task-detail__timestamps", children: [
+            task.created_at && /* @__PURE__ */ jsxs18("span", { className: "task-detail__timestamp", children: [
+              "Created: ",
+              new Date(task.created_at).toLocaleDateString()
+            ] }),
+            task.updated_at && /* @__PURE__ */ jsxs18("span", { className: "task-detail__timestamp", children: [
+              "Updated: ",
+              new Date(task.updated_at).toLocaleDateString()
+            ] })
+          ] }),
+          task.evidence && task.evidence.length > 0 && /* @__PURE__ */ jsx20(EvidenceLog, { evidence: task.evidence })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/widgets/BacklogTreeWidget.tsx
+import { useState as useState17, useMemo as useMemo5, useCallback as useCallback18 } from "react";
+import { Widget } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon6 } from "@orchestra-mcp/icons";
+import { ContextMenu } from "@orchestra-mcp/ui";
+
+// src/widgets/BacklogTreeHeader.tsx
+import { jsx as jsx21, jsxs as jsxs19 } from "react/jsx-runtime";
+var FILTERS = [
+  { key: "all", label: "All" },
+  { key: "todo", label: "To Do" },
+  { key: "in-progress", label: "In Progress" },
+  { key: "blocked", label: "Blocked" },
+  { key: "done", label: "Done" }
+];
+var BacklogTreeHeader = ({
+  totalTasks,
+  doneTasks,
+  searchQuery,
+  onSearchChange,
+  activeFilter,
+  onFilterChange
+}) => {
+  return /* @__PURE__ */ jsxs19("div", { className: "backlog-header", "data-testid": "backlog-tree-header", children: [
+    /* @__PURE__ */ jsxs19("div", { className: "backlog-header__top", children: [
+      /* @__PURE__ */ jsx21(
+        "input",
+        {
+          type: "text",
+          className: "backlog-header__search",
+          placeholder: "Search backlog...",
+          value: searchQuery,
+          onChange: (e) => onSearchChange(e.target.value),
+          "data-testid": "backlog-search"
+        }
+      ),
+      /* @__PURE__ */ jsxs19("span", { className: "backlog-header__count", children: [
+        doneTasks,
+        "/",
+        totalTasks
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx21("div", { className: "backlog-header__filters", children: FILTERS.map((f) => /* @__PURE__ */ jsx21(
+      "button",
+      {
+        type: "button",
+        className: `backlog-header__filter${activeFilter === f.key ? " backlog-header__filter--active" : ""}`,
+        onClick: () => onFilterChange(f.key),
+        "data-testid": `backlog-filter-${f.key}`,
+        children: f.label
+      },
+      f.key
+    )) })
+  ] });
+};
+
+// src/widgets/BacklogTreeWidget.tsx
+import { Fragment as Fragment4, jsx as jsx22, jsxs as jsxs20 } from "react/jsx-runtime";
+var TYPE_ICON_NAMES = {
+  task: "bx-checkbox-checked",
+  bug: "bx-bug",
+  hotfix: "bx-badge-check",
+  story: "bx-book-bookmark",
+  epic: "bx-layer"
+};
+var PRIORITY_COLORS2 = {
+  low: "#22c55e",
+  medium: "#eab308",
+  high: "#f97316",
+  critical: "#ef4444"
+};
+var STATUS_FILTER_MAP = {
+  all: [],
+  todo: ["backlog", "todo"],
+  "in-progress": ["in-progress", "in-testing", "in-docs", "in-review"],
+  blocked: ["blocked"],
+  done: ["done", "documented", "cancelled"]
+};
+function nodeMatches(node, query, statusFilter) {
+  const titleMatch = !query || node.title.toLowerCase().includes(query.toLowerCase());
+  const statusMatch = statusFilter.length === 0 || statusFilter.includes(node.status);
+  if (titleMatch && statusMatch) return true;
+  if (node.children?.some((c) => nodeMatches(c, query, statusFilter))) return true;
+  return false;
+}
+function countTasks(node) {
+  if (!node.children || node.children.length === 0) {
+    return { total: 1, done: node.status === "done" ? 1 : 0 };
+  }
+  let total = 0;
+  let done = 0;
+  for (const child of node.children) {
+    const c = countTasks(child);
+    total += c.total;
+    done += c.done;
+  }
+  return { total, done };
+}
+function sumEstimate(node) {
+  if (node.estimate) return node.estimate;
+  if (!node.children) return 0;
+  return node.children.reduce((sum, c) => sum + sumEstimate(c), 0);
+}
+var LABEL_COLORS = [
+  "#ef4444",
+  "#f97316",
+  "#eab308",
+  "#22c55e",
+  "#06b6d4",
+  "#3b82f6",
+  "#8b5cf6",
+  "#ec4899",
+  "#14b8a6",
+  "#f59e0b"
+];
+function labelColor(label) {
+  let hash = 0;
+  for (let i = 0; i < label.length; i++) hash = hash * 31 + label.charCodeAt(i) | 0;
+  return LABEL_COLORS[Math.abs(hash) % LABEL_COLORS.length];
+}
+var TreeNodeRow = ({
+  node,
+  depth,
+  expandedNodes,
+  selectedNode,
+  onNodeClick,
+  onNodeExpand,
+  onNodeAction
+}) => {
+  const hasChildren = node.children && node.children.length > 0;
+  const isExpanded = expandedNodes.has(node.id);
+  const isSelected = selectedNode === node.id;
+  const handleClick = (e) => {
+    if (node.type === "task" || node.type === "bug" || node.type === "hotfix") {
+      onNodeClick?.(node);
+      return;
+    }
+    if (hasChildren) {
+      onNodeExpand?.(node.id);
+    }
+    onNodeClick?.(node);
+  };
+  const contextMenuItems = useMemo5(() => {
+    const items = [];
+    items.push({
+      id: "view",
+      label: "View Details",
+      icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-show", size: 14 })
+    });
+    if (node.type === "task" || node.type === "bug" || node.type === "hotfix") {
+      items.push({ id: "sep-1", label: "", separator: true });
+      if (node.status === "backlog" || node.status === "todo") {
+        items.push({
+          id: "start",
+          label: "Start Task",
+          icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-play", size: 14 }),
+          color: "success"
+        });
+      }
+      if (node.status === "in-progress") {
+        items.push({
+          id: "complete",
+          label: "Mark Complete",
+          icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-check", size: 14 }),
+          color: "success"
+        });
+      }
+      if (node.status !== "blocked") {
+        items.push({
+          id: "block",
+          label: "Block Task",
+          icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-block", size: 14 }),
+          color: "warning"
+        });
+      }
+      items.push({ id: "sep-2", label: "", separator: true });
+      items.push({
+        id: "delete",
+        label: "Delete Task",
+        icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-trash", size: 14 }),
+        color: "danger"
+      });
+    }
+    return items;
+  }, [node.type, node.status]);
+  const handleContextAction = useCallback18((actionId) => {
+    if (actionId === "view") {
+      onNodeClick?.(node);
+    } else {
+      onNodeAction?.(actionId, node);
+    }
+  }, [node, onNodeClick, onNodeAction]);
+  const nodeClasses = [
+    "backlog-tree__node",
+    isSelected ? "backlog-tree__node--selected" : ""
+  ].filter(Boolean).join(" ");
+  const expandClasses = [
+    "backlog-tree__expand",
+    hasChildren && isExpanded ? "backlog-tree__expand--open" : "",
+    !hasChildren ? "backlog-tree__expand--hidden" : ""
+  ].filter(Boolean).join(" ");
+  const counts = hasChildren ? countTasks(node) : null;
+  const pct = counts && counts.total > 0 ? counts.done / counts.total * 100 : 0;
+  const est = sumEstimate(node);
+  return /* @__PURE__ */ jsxs20(Fragment4, { children: [
+    /* @__PURE__ */ jsx22(ContextMenu, { items: contextMenuItems, onAction: handleContextAction, children: /* @__PURE__ */ jsxs20(
+      "button",
+      {
+        type: "button",
+        className: nodeClasses,
+        style: { paddingLeft: `${10 + depth * 20}px` },
+        "data-testid": `tree-node-${node.id}`,
+        onClick: handleClick,
+        children: [
+          /* @__PURE__ */ jsx22("span", { className: expandClasses, "aria-hidden": "true", children: /* @__PURE__ */ jsx22(BoxIcon6, { name: isExpanded ? "bx-chevron-down" : "bx-chevron-right", size: 14 }) }),
+          /* @__PURE__ */ jsx22("span", { className: "backlog-tree__type-icon", children: /* @__PURE__ */ jsx22(BoxIcon6, { name: TYPE_ICON_NAMES[node.type] || "bx-circle", size: 14 }) }),
+          /* @__PURE__ */ jsx22("span", { className: "backlog-tree__title", children: node.title }),
+          node.labels && node.labels.length > 0 && /* @__PURE__ */ jsx22("span", { className: "backlog-tree__labels", children: node.labels.map((label) => /* @__PURE__ */ jsx22(
+            "span",
+            {
+              className: "backlog-tree__label",
+              style: { backgroundColor: labelColor(label) },
+              children: label
+            },
+            label
+          )) }),
+          est > 0 && /* @__PURE__ */ jsxs20("span", { className: "backlog-tree__estimate", children: [
+            est,
+            "pts"
+          ] }),
+          counts && /* @__PURE__ */ jsxs20("span", { className: "backlog-tree__task-count", title: `${counts.done}/${counts.total} done`, children: [
+            counts.total,
+            " tasks"
+          ] }),
+          counts && counts.total > 0 && /* @__PURE__ */ jsx22("span", { className: "backlog-tree__mini-bar", children: /* @__PURE__ */ jsx22("span", { className: "backlog-tree__mini-bar-fill", style: { width: `${pct}%` } }) }),
+          /* @__PURE__ */ jsx22("span", { className: "backlog-tree__status", children: node.status }),
+          node.priority && /* @__PURE__ */ jsx22(
+            "span",
+            {
+              className: "backlog-tree__priority-dot",
+              style: { backgroundColor: PRIORITY_COLORS2[node.priority] },
+              title: node.priority
+            }
+          )
+        ]
+      }
+    ) }),
+    hasChildren && isExpanded && /* @__PURE__ */ jsx22("div", { className: "backlog-tree__children", "data-testid": `tree-children-${node.id}`, children: node.children.map((child) => /* @__PURE__ */ jsx22(
+      TreeNodeRow,
+      {
+        node: child,
+        depth: depth + 1,
+        expandedNodes,
+        selectedNode,
+        onNodeClick,
+        onNodeExpand,
+        onNodeAction
+      },
+      child.id
+    )) })
+  ] });
+};
+var EMPTY_SET = /* @__PURE__ */ new Set();
+var BacklogTreeWidget = ({
+  tree,
+  onNodeClick,
+  onNodeExpand,
+  onNodeAction,
+  expandedNodes = EMPTY_SET,
+  selectedNode = null,
+  totalTasks = 0,
+  doneTasks = 0,
+  showHeader = true,
+  loading,
+  onRefresh,
+  onFullView
+}) => {
+  const [searchQuery, setSearchQuery] = useState17("");
+  const [activeFilter, setActiveFilter] = useState17("all");
+  const [internalExpanded, setInternalExpanded] = useState17(/* @__PURE__ */ new Set());
+  const effectiveExpanded = expandedNodes !== EMPTY_SET ? expandedNodes : internalExpanded;
+  const isControlled = expandedNodes !== EMPTY_SET;
+  const handleNodeExpand = (nodeId) => {
+    if (isControlled) {
+      onNodeExpand?.(nodeId);
+    } else {
+      setInternalExpanded((prev) => {
+        const next = new Set(prev);
+        if (next.has(nodeId)) {
+          next.delete(nodeId);
+        } else {
+          next.add(nodeId);
+        }
+        return next;
+      });
+    }
+  };
+  const handleExpandAll = () => {
+    const allIds = /* @__PURE__ */ new Set();
+    const collectIds = (nodes) => {
+      nodes.forEach((node) => {
+        if (node.children && node.children.length > 0) {
+          allIds.add(node.id);
+          collectIds(node.children);
+        }
+      });
+    };
+    collectIds(tree);
+    if (!isControlled) {
+      setInternalExpanded(allIds);
+    }
+  };
+  const handleCollapseAll = () => {
+    if (!isControlled) {
+      setInternalExpanded(/* @__PURE__ */ new Set());
+    }
+  };
+  const filteredTree = useMemo5(() => {
+    const statusFilter = STATUS_FILTER_MAP[activeFilter] ?? [];
+    if (!searchQuery && statusFilter.length === 0) return tree;
+    return tree.filter((node) => nodeMatches(node, searchQuery, statusFilter));
+  }, [tree, searchQuery, activeFilter]);
+  const widgetActions = [
+    {
+      id: "expand-all",
+      label: "Expand All",
+      icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-expand-alt", size: 16 }),
+      onClick: handleExpandAll
+    },
+    {
+      id: "collapse-all",
+      label: "Collapse All",
+      icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-collapse-alt", size: 16 }),
+      onClick: handleCollapseAll
+    },
+    ...onFullView ? [
+      {
+        id: "full-view",
+        label: "Full View",
+        icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-fullscreen", size: 16 }),
+        onClick: onFullView
+      }
+    ] : []
+  ];
+  return /* @__PURE__ */ jsx22(
+    Widget,
+    {
+      title: "Backlog",
+      icon: /* @__PURE__ */ jsx22(BoxIcon6, { name: "bx-list-ul", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      actions: widgetActions,
+      children: /* @__PURE__ */ jsxs20("div", { className: "backlog-tree-wrapper", "data-testid": "backlog-tree-widget", children: [
+        showHeader && /* @__PURE__ */ jsx22(
+          BacklogTreeHeader,
+          {
+            totalTasks,
+            doneTasks,
+            searchQuery,
+            onSearchChange: setSearchQuery,
+            activeFilter,
+            onFilterChange: setActiveFilter
+          }
+        ),
+        filteredTree.length === 0 ? /* @__PURE__ */ jsx22("div", { className: "backlog-tree__empty", "data-testid": "backlog-tree-empty", children: searchQuery || activeFilter !== "all" ? "No matching items" : "No items in backlog" }) : /* @__PURE__ */ jsx22("div", { className: "backlog-tree", children: filteredTree.map((node) => /* @__PURE__ */ jsx22(
+          TreeNodeRow,
+          {
+            node,
+            depth: 0,
+            expandedNodes: effectiveExpanded,
+            selectedNode,
+            onNodeClick,
+            onNodeExpand: handleNodeExpand,
+            onNodeAction
+          },
+          node.id
+        )) })
+      ] })
+    }
+  );
+};
+
+// src/widgets/TaskDistributionWidget.tsx
+import { Widget as Widget2 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon7 } from "@orchestra-mcp/icons";
+import { jsx as jsx23, jsxs as jsxs21 } from "react/jsx-runtime";
+var TAB_LABELS = {
+  status: "By Status",
+  priority: "By Priority",
+  type: "By Type"
+};
+var TABS = ["status", "priority", "type"];
+var TaskDistributionWidget = ({
+  byStatus,
+  byPriority,
+  byType,
+  activeChart = "status",
+  onChartChange,
+  loading,
+  onRefresh
+}) => {
+  const dataMap = {
+    status: byStatus,
+    priority: byPriority,
+    type: byType
+  };
+  const data = dataMap[activeChart] || [];
+  const maxValue = Math.max(...data.map((d) => d.value), 1);
+  return /* @__PURE__ */ jsx23(
+    Widget2,
+    {
+      title: "Task Distribution",
+      icon: /* @__PURE__ */ jsx23(BoxIcon7, { name: "bx-bar-chart-square", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: data.length === 0 ? /* @__PURE__ */ jsx23("div", { className: "task-distribution__empty", "data-testid": "task-distribution-empty", children: "No distribution data" }) : /* @__PURE__ */ jsxs21("div", { className: "task-distribution", "data-testid": "task-distribution-widget", children: [
+        /* @__PURE__ */ jsx23("div", { className: "task-distribution__tabs", "data-testid": "task-distribution-tabs", children: TABS.map((key) => /* @__PURE__ */ jsx23(
+          "button",
+          {
+            type: "button",
+            className: [
+              "task-distribution__tab",
+              activeChart === key ? "task-distribution__tab--active" : ""
+            ].filter(Boolean).join(" "),
+            "data-testid": `tab-${key}`,
+            onClick: () => onChartChange?.(key),
+            children: TAB_LABELS[key]
+          },
+          key
+        )) }),
+        /* @__PURE__ */ jsx23("div", { className: "task-distribution__chart", "data-testid": "task-distribution-chart", children: data.map((point) => {
+          const widthPercent = point.value / maxValue * 100;
+          return /* @__PURE__ */ jsxs21("div", { className: "task-distribution__row", children: [
+            /* @__PURE__ */ jsx23("span", { className: "task-distribution__label", title: point.label, children: point.label }),
+            /* @__PURE__ */ jsx23("div", { className: "task-distribution__bar-track", children: /* @__PURE__ */ jsx23(
+              "div",
+              {
+                className: "task-distribution__bar-fill",
+                style: {
+                  width: `${widthPercent}%`,
+                  backgroundColor: point.color
+                }
+              }
+            ) }),
+            /* @__PURE__ */ jsx23("span", { className: "task-distribution__value", children: point.value })
+          ] }, point.label);
+        }) })
+      ] })
+    }
+  );
+};
+
+// src/widgets/RecentActivityWidget.tsx
+import { Widget as Widget3 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon8 } from "@orchestra-mcp/icons";
+import { jsx as jsx24, jsxs as jsxs22 } from "react/jsx-runtime";
+var TYPE_ICONS4 = {
+  created: "\u2728",
+  updated: "\u270F\uFE0F",
+  completed: "\u2705",
+  commented: "\u{1F4AC}",
+  synced: "\u{1F504}"
+};
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const then = new Date(timestamp).getTime();
+  const diffSeconds = Math.floor((now - then) / 1e3);
+  if (diffSeconds < 60) return "just now";
+  const diffMinutes = Math.floor(diffSeconds / 60);
+  if (diffMinutes < 60) return `${diffMinutes}m ago`;
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 24) return `${diffHours}h ago`;
+  const diffDays = Math.floor(diffHours / 24);
+  if (diffDays < 30) return `${diffDays}d ago`;
+  return `${Math.floor(diffDays / 30)}mo ago`;
+}
+var RecentActivityWidget = ({
+  activities,
+  onActivityClick,
+  maxItems = 20,
+  loading,
+  onRefresh
+}) => {
+  const visibleItems = activities.slice(0, maxItems);
+  return /* @__PURE__ */ jsx24(
+    Widget3,
+    {
+      title: "Recent Activity",
+      icon: /* @__PURE__ */ jsx24(BoxIcon8, { name: "bx-time-five", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: visibleItems.length === 0 ? /* @__PURE__ */ jsx24("div", { className: "recent-activity__empty", "data-testid": "recent-activity-empty", children: "No recent activity" }) : /* @__PURE__ */ jsx24("div", { className: "recent-activity", "data-testid": "recent-activity-widget", children: visibleItems.map((item) => /* @__PURE__ */ jsxs22(
+        "button",
+        {
+          type: "button",
+          className: "recent-activity__item",
+          "data-testid": `activity-${item.id}`,
+          onClick: () => onActivityClick?.(item),
+          children: [
+            /* @__PURE__ */ jsx24("span", { className: "recent-activity__icon", children: TYPE_ICONS4[item.type] }),
+            /* @__PURE__ */ jsxs22("div", { className: "recent-activity__body", children: [
+              /* @__PURE__ */ jsx24("span", { className: "recent-activity__title", children: item.issueTitle }),
+              item.detail && /* @__PURE__ */ jsx24("span", { className: "recent-activity__detail", children: item.detail })
+            ] }),
+            /* @__PURE__ */ jsxs22("div", { className: "recent-activity__meta", children: [
+              /* @__PURE__ */ jsx24("span", { className: "recent-activity__time", children: formatRelativeTime(item.timestamp) }),
+              item.provider && item.provider !== "local" && /* @__PURE__ */ jsx24("span", { className: "recent-activity__provider", children: item.provider })
+            ] })
+          ]
+        },
+        item.id
+      )) })
+    }
+  );
+};
+
+// src/widgets/SprintProgressWidget.tsx
+import { Widget as Widget4 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon9 } from "@orchestra-mcp/icons";
+import { jsx as jsx25, jsxs as jsxs23 } from "react/jsx-runtime";
+function computeDaysRemaining(endDate) {
+  const end = new Date(endDate).getTime();
+  const now = Date.now();
+  const diff = end - now;
+  return Math.max(0, Math.ceil(diff / (1e3 * 60 * 60 * 24)));
+}
+function formatDate(dateStr) {
+  const d = new Date(dateStr);
+  return d.toLocaleDateString(void 0, { month: "short", day: "numeric" });
+}
+function percent(completed, total) {
+  if (total === 0) return 0;
+  return Math.min(100, Math.round(completed / total * 100));
+}
+var SprintProgressWidget = ({
+  sprint,
+  noSprintMessage = "No active sprint",
+  loading,
+  onRefresh
+}) => {
+  const daysLeft = sprint ? computeDaysRemaining(sprint.endDate) : 0;
+  const pointsPercent = sprint ? percent(sprint.completedPoints, sprint.totalPoints) : 0;
+  const tasksPercent = sprint ? percent(sprint.completedTasks, sprint.totalTasks) : 0;
+  return /* @__PURE__ */ jsx25(
+    Widget4,
+    {
+      title: "Sprint Progress",
+      icon: /* @__PURE__ */ jsx25(BoxIcon9, { name: "bx-line-chart", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: !sprint ? /* @__PURE__ */ jsx25("div", { className: "sprint-progress__empty", "data-testid": "sprint-progress-empty", children: noSprintMessage }) : /* @__PURE__ */ jsxs23("div", { className: "sprint-progress", "data-testid": "sprint-progress-widget", children: [
+        /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__header", children: [
+          /* @__PURE__ */ jsxs23("div", { children: [
+            /* @__PURE__ */ jsx25("div", { className: "sprint-progress__name", children: sprint.name }),
+            /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__dates", children: [
+              formatDate(sprint.startDate),
+              " \u2013 ",
+              formatDate(sprint.endDate)
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__days", "data-testid": "sprint-days-remaining", children: [
+            daysLeft,
+            " ",
+            daysLeft === 1 ? "day" : "days",
+            " left"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__bars", children: [
+          /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__metric", children: [
+            /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__metric-header", children: [
+              /* @__PURE__ */ jsx25("span", { children: "Points" }),
+              /* @__PURE__ */ jsxs23("span", { className: "sprint-progress__metric-value", children: [
+                sprint.completedPoints,
+                "/",
+                sprint.totalPoints
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx25("div", { className: "sprint-progress__bar-track", children: /* @__PURE__ */ jsx25(
+              "div",
+              {
+                className: "sprint-progress__bar-fill sprint-progress__bar-fill--points",
+                style: { width: `${pointsPercent}%` },
+                "data-testid": "sprint-points-bar"
+              }
+            ) })
+          ] }),
+          /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__metric", children: [
+            /* @__PURE__ */ jsxs23("div", { className: "sprint-progress__metric-header", children: [
+              /* @__PURE__ */ jsx25("span", { children: "Tasks" }),
+              /* @__PURE__ */ jsxs23("span", { className: "sprint-progress__metric-value", children: [
+                sprint.completedTasks,
+                "/",
+                sprint.totalTasks
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx25("div", { className: "sprint-progress__bar-track", children: /* @__PURE__ */ jsx25(
+              "div",
+              {
+                className: "sprint-progress__bar-fill sprint-progress__bar-fill--tasks",
+                style: { width: `${tasksPercent}%` },
+                "data-testid": "sprint-tasks-bar"
+              }
+            ) })
+          ] })
+        ] })
+      ] })
+    }
+  );
+};
+
+// src/widgets/TeamWorkloadWidget.tsx
+import { Widget as Widget5 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon10 } from "@orchestra-mcp/icons";
+import { jsx as jsx26, jsxs as jsxs24 } from "react/jsx-runtime";
+function getInitials2(name) {
+  return name.split(" ").map((w) => w[0]).join("").toUpperCase().slice(0, 2);
+}
+function segmentPercent(value, total) {
+  if (total === 0) return 0;
+  return value / total * 100;
+}
+var TeamWorkloadWidget = ({
+  members,
+  onMemberClick,
+  loading,
+  onRefresh
+}) => {
+  return /* @__PURE__ */ jsx26(
+    Widget5,
+    {
+      title: "Team Workload",
+      icon: /* @__PURE__ */ jsx26(BoxIcon10, { name: "bx-group", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: members.length === 0 ? /* @__PURE__ */ jsx26("div", { className: "team-workload__empty", "data-testid": "team-workload-empty", children: "No team members" }) : /* @__PURE__ */ jsxs24("div", { className: "team-workload", "data-testid": "team-workload-widget", children: [
+        members.map((member) => {
+          const total = member.assigned + member.inProgress + member.completed;
+          return /* @__PURE__ */ jsxs24(
+            "button",
+            {
+              type: "button",
+              className: "team-workload__row",
+              "data-testid": `member-${member.name}`,
+              onClick: () => onMemberClick?.(member.name),
+              children: [
+                /* @__PURE__ */ jsx26("div", { className: "team-workload__avatar", children: member.avatar ? /* @__PURE__ */ jsx26("img", { src: member.avatar, alt: member.name }) : getInitials2(member.name) }),
+                /* @__PURE__ */ jsxs24("div", { className: "team-workload__info", children: [
+                  /* @__PURE__ */ jsx26("span", { className: "team-workload__name", children: member.name }),
+                  /* @__PURE__ */ jsxs24("div", { className: "team-workload__bar-track", children: [
+                    /* @__PURE__ */ jsx26(
+                      "div",
+                      {
+                        className: "team-workload__segment team-workload__segment--completed",
+                        style: { width: `${segmentPercent(member.completed, total)}%` }
+                      }
+                    ),
+                    /* @__PURE__ */ jsx26(
+                      "div",
+                      {
+                        className: "team-workload__segment team-workload__segment--in-progress",
+                        style: { width: `${segmentPercent(member.inProgress, total)}%` }
+                      }
+                    ),
+                    /* @__PURE__ */ jsx26(
+                      "div",
+                      {
+                        className: "team-workload__segment team-workload__segment--assigned",
+                        style: { width: `${segmentPercent(member.assigned, total)}%` }
+                      }
+                    )
+                  ] })
+                ] }),
+                /* @__PURE__ */ jsx26("span", { className: "team-workload__count", children: total })
+              ]
+            },
+            member.name
+          );
+        }),
+        /* @__PURE__ */ jsxs24("div", { className: "team-workload__legend", "data-testid": "team-workload-legend", children: [
+          /* @__PURE__ */ jsxs24("span", { className: "team-workload__legend-item", children: [
+            /* @__PURE__ */ jsx26("span", { className: "team-workload__legend-dot", style: { background: "#22c55e" } }),
+            "Done"
+          ] }),
+          /* @__PURE__ */ jsxs24("span", { className: "team-workload__legend-item", children: [
+            /* @__PURE__ */ jsx26("span", { className: "team-workload__legend-dot", style: { background: "#3b82f6" } }),
+            "In Progress"
+          ] }),
+          /* @__PURE__ */ jsxs24("span", { className: "team-workload__legend-item", children: [
+            /* @__PURE__ */ jsx26("span", { className: "team-workload__legend-dot", style: { background: "#888", opacity: 0.4 } }),
+            "Assigned"
+          ] })
+        ] })
+      ] })
+    }
+  );
+};
+
+// src/widgets/ProgressDistributionWidget.tsx
+import { Widget as Widget6, DonutChart } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon11 } from "@orchestra-mcp/icons";
+import { jsx as jsx27, jsxs as jsxs25 } from "react/jsx-runtime";
+var ProgressDistributionWidget = ({
+  data,
+  completionPercent,
+  loading,
+  onRefresh
+}) => {
+  return /* @__PURE__ */ jsx27(
+    Widget6,
+    {
+      title: "Progress Distribution",
+      icon: /* @__PURE__ */ jsx27(BoxIcon11, { name: "bx-doughnut-chart", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: data.length === 0 ? /* @__PURE__ */ jsx27("div", { className: "progress-dist__empty", children: "No data" }) : /* @__PURE__ */ jsxs25("div", { className: "progress-dist", children: [
+        /* @__PURE__ */ jsx27(
+          DonutChart,
+          {
+            data,
+            width: 180,
+            height: 180,
+            showLegend: false,
+            innerRatio: 0.65,
+            centerLabel: `${Math.round(completionPercent)}%`,
+            className: "progress-dist__chart"
+          }
+        ),
+        /* @__PURE__ */ jsx27("div", { className: "progress-dist__legend", children: data.map((point) => /* @__PURE__ */ jsxs25("div", { className: "progress-dist__legend-row", children: [
+          /* @__PURE__ */ jsx27(
+            "span",
+            {
+              className: "progress-dist__legend-dot",
+              style: { backgroundColor: point.color }
+            }
+          ),
+          /* @__PURE__ */ jsx27("span", { className: "progress-dist__legend-label", children: point.label }),
+          /* @__PURE__ */ jsx27("span", { className: "progress-dist__legend-value", children: point.value })
+        ] }, point.label)) })
+      ] })
+    }
+  );
+};
+
+// src/widgets/ActiveTasksWidget.tsx
+import { Widget as Widget7 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon12 } from "@orchestra-mcp/icons";
+import { jsx as jsx28, jsxs as jsxs26 } from "react/jsx-runtime";
+var PRIORITY_COLORS3 = {
+  low: "#22c55e",
+  medium: "#eab308",
+  high: "#f97316",
+  critical: "#ef4444"
+};
+var ActiveTasksWidget = ({
+  tasks,
+  onTaskClick,
+  loading,
+  onRefresh
+}) => {
+  const breadcrumb = (task) => {
+    const parts = [];
+    if (task.epicTitle) parts.push(task.epicTitle);
+    if (task.storyTitle) parts.push(task.storyTitle);
+    return parts.length > 0 ? parts.join(" > ") : null;
+  };
+  return /* @__PURE__ */ jsx28(
+    Widget7,
+    {
+      title: "Active Tasks",
+      icon: /* @__PURE__ */ jsx28(BoxIcon12, { name: "bx-task", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: tasks.length === 0 ? /* @__PURE__ */ jsxs26("div", { className: "active-tasks__empty", "data-testid": "active-tasks-empty", children: [
+        /* @__PURE__ */ jsxs26(
+          "svg",
+          {
+            className: "active-tasks__empty-icon",
+            viewBox: "0 0 48 48",
+            fill: "none",
+            xmlns: "http://www.w3.org/2000/svg",
+            children: [
+              /* @__PURE__ */ jsx28(
+                "circle",
+                {
+                  cx: "24",
+                  cy: "24",
+                  r: "20",
+                  stroke: "var(--color-accent, #22c55e)",
+                  strokeWidth: "3",
+                  fill: "none"
+                }
+              ),
+              /* @__PURE__ */ jsx28(
+                "path",
+                {
+                  d: "M15 25l6 6 12-12",
+                  stroke: "var(--color-accent, #22c55e)",
+                  strokeWidth: "3",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round",
+                  fill: "none"
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx28("h3", { children: "All Clear" }),
+        /* @__PURE__ */ jsx28("p", { children: "No tasks currently in progress. Ready to start something new?" })
+      ] }) : /* @__PURE__ */ jsxs26("div", { className: "active-tasks", "data-testid": "active-tasks-widget", children: [
+        /* @__PURE__ */ jsxs26("span", { className: "active-tasks__count", children: [
+          tasks.length,
+          " ",
+          tasks.length === 1 ? "task" : "tasks"
+        ] }),
+        /* @__PURE__ */ jsx28("div", { className: "active-tasks__list", children: tasks.map((task) => /* @__PURE__ */ jsxs26(
+          "button",
+          {
+            type: "button",
+            className: "active-tasks__item",
+            "data-testid": `active-task-${task.id}`,
+            onClick: () => onTaskClick?.(task.id),
+            children: [
+              /* @__PURE__ */ jsx28(
+                "span",
+                {
+                  className: "active-tasks__priority-dot",
+                  style: {
+                    backgroundColor: PRIORITY_COLORS3[task.priority ?? ""] ?? "#555"
+                  }
+                }
+              ),
+              /* @__PURE__ */ jsxs26("div", { className: "active-tasks__info", children: [
+                /* @__PURE__ */ jsx28("span", { className: "active-tasks__title", children: task.title }),
+                breadcrumb(task) && /* @__PURE__ */ jsx28("span", { className: "active-tasks__breadcrumb", children: breadcrumb(task) })
+              ] }),
+              /* @__PURE__ */ jsx28("span", { className: "active-tasks__badge", children: task.status })
+            ]
+          },
+          task.id
+        )) })
+      ] })
+    }
+  );
+};
+
+// src/widgets/SessionMetricsWidget.tsx
+import { Widget as Widget8 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon13 } from "@orchestra-mcp/icons";
+import { jsx as jsx29, jsxs as jsxs27 } from "react/jsx-runtime";
+var ACCENT_COLOR = "var(--color-accent, #7c3aed)";
+var SessionMetricsWidget = ({
+  kpis,
+  loading,
+  onRefresh
+}) => {
+  return /* @__PURE__ */ jsx29(
+    Widget8,
+    {
+      title: "Session Metrics",
+      icon: /* @__PURE__ */ jsx29(BoxIcon13, { name: "bx-trending-up", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: kpis.length === 0 ? /* @__PURE__ */ jsx29("div", { className: "session-metrics__empty", "data-testid": "session-metrics-empty", children: "No session data" }) : /* @__PURE__ */ jsx29("div", { className: "session-metrics", "data-testid": "session-metrics-widget", children: kpis.map((kpi) => /* @__PURE__ */ jsxs27(
+        "div",
+        {
+          className: "session-metrics__card",
+          style: { borderTopColor: kpi.color || ACCENT_COLOR },
+          "data-testid": `session-kpi-${kpi.label.toLowerCase().replace(/\s+/g, "-")}`,
+          children: [
+            /* @__PURE__ */ jsx29("span", { className: "session-metrics__label", children: kpi.label }),
+            /* @__PURE__ */ jsx29("span", { className: "session-metrics__value", children: kpi.value })
+          ]
+        },
+        kpi.label
+      )) })
+    }
+  );
+};
+
+// src/widgets/FeatureAdoptionWidget.tsx
+import { Widget as Widget9 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon14 } from "@orchestra-mcp/icons";
+import { jsx as jsx30, jsxs as jsxs28 } from "react/jsx-runtime";
+var BAR_COLOR = "var(--color-accent, #7c3aed)";
+var FeatureAdoptionWidget = ({
+  features,
+  maxCount,
+  loading,
+  onRefresh
+}) => {
+  const resolvedMax = maxCount ?? Math.max(...features.map((f) => f.count), 1);
+  return /* @__PURE__ */ jsx30(
+    Widget9,
+    {
+      title: "Feature Adoption",
+      icon: /* @__PURE__ */ jsx30(BoxIcon14, { name: "bx-star", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: features.length === 0 ? /* @__PURE__ */ jsx30("div", { className: "feature-adoption__empty", "data-testid": "feature-adoption-empty", children: "No feature data" }) : /* @__PURE__ */ jsx30("div", { className: "feature-adoption", "data-testid": "feature-adoption-widget", children: features.map((entry) => {
+        const widthPercent = Math.round(entry.count / resolvedMax * 100);
+        return /* @__PURE__ */ jsxs28(
+          "div",
+          {
+            className: "feature-adoption__row",
+            "data-testid": `feature-row-${entry.feature}`,
+            children: [
+              /* @__PURE__ */ jsx30("span", { className: "feature-adoption__name", children: entry.feature }),
+              /* @__PURE__ */ jsx30("div", { className: "feature-adoption__bar-track", children: /* @__PURE__ */ jsx30(
+                "div",
+                {
+                  className: "feature-adoption__bar-fill",
+                  style: {
+                    width: `${widthPercent}%`,
+                    backgroundColor: entry.color || BAR_COLOR
+                  }
+                }
+              ) }),
+              /* @__PURE__ */ jsx30("span", { className: "feature-adoption__count", children: entry.count })
+            ]
+          },
+          entry.feature
+        );
+      }) })
+    }
+  );
+};
+
+// src/widgets/ProjectStatusWidget.tsx
+import { Widget as Widget10 } from "@orchestra-mcp/widgets";
+import { BoxIcon as BoxIcon15 } from "@orchestra-mcp/icons";
+import { jsx as jsx31, jsxs as jsxs29 } from "react/jsx-runtime";
+var ProjectStatusWidget = ({
+  totalTasks,
+  doneTasks,
+  completionPercent,
+  statuses,
+  loading,
+  onRefresh
+}) => {
+  const clampedPercent = Math.min(100, Math.max(0, completionPercent));
+  return /* @__PURE__ */ jsx31(
+    Widget10,
+    {
+      title: "Project Status",
+      icon: /* @__PURE__ */ jsx31(BoxIcon15, { name: "bx-bar-chart-alt-2", size: 16 }),
+      collapsible: true,
+      size: "medium",
+      loading,
+      onRefresh,
+      children: /* @__PURE__ */ jsxs29("div", { className: "project-status-widget", children: [
+        /* @__PURE__ */ jsxs29("div", { className: "project-status-widget__summary", children: [
+          /* @__PURE__ */ jsxs29("div", { className: "project-status-widget__stat", children: [
+            /* @__PURE__ */ jsx31("span", { className: "project-status-widget__stat-value", children: totalTasks }),
+            /* @__PURE__ */ jsx31("span", { className: "project-status-widget__stat-label", children: "Total Tasks" })
+          ] }),
+          /* @__PURE__ */ jsxs29("div", { className: "project-status-widget__stat", children: [
+            /* @__PURE__ */ jsx31("span", { className: "project-status-widget__stat-value", children: doneTasks }),
+            /* @__PURE__ */ jsx31("span", { className: "project-status-widget__stat-label", children: "Completed" })
+          ] }),
+          /* @__PURE__ */ jsxs29("div", { className: "project-status-widget__stat", children: [
+            /* @__PURE__ */ jsxs29("span", { className: "project-status-widget__stat-value", children: [
+              clampedPercent,
+              "%"
+            ] }),
+            /* @__PURE__ */ jsx31("span", { className: "project-status-widget__stat-label", children: "Completion" })
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx31("div", { className: "project-status-widget__progress", children: /* @__PURE__ */ jsx31(
+          "div",
+          {
+            className: "project-status-widget__progress-fill",
+            style: { width: `${clampedPercent}%` }
+          }
+        ) }),
+        /* @__PURE__ */ jsx31("div", { className: "project-status-widget__statuses", children: statuses.map((s) => /* @__PURE__ */ jsxs29("div", { className: "project-status-widget__status-chip", children: [
+          /* @__PURE__ */ jsx31(
+            "span",
+            {
+              className: "project-status-widget__status-dot",
+              style: { backgroundColor: s.color }
+            }
+          ),
+          /* @__PURE__ */ jsx31("span", { className: "project-status-widget__status-label", children: s.label }),
+          /* @__PURE__ */ jsx31("span", { className: "project-status-widget__status-count", children: s.count })
+        ] }, s.status)) })
+      ] })
+    }
+  );
+};
+
+// src/ProjectDashboard/defaultLayout.ts
+var WIDGET_TITLES = {
+  "project-status": "Project Status",
+  "backlog-tree": "Backlog",
+  "task-distribution": "Task Distribution",
+  "progress-distribution": "Progress Distribution",
+  "active-tasks": "Active Tasks",
+  "recent-activity": "Recent Activity",
+  "sprint-progress": "Sprint Progress",
+  "team-workload": "Team Workload",
+  "session-metrics": "Session Metrics",
+  "feature-adoption": "Feature Adoption"
+};
+
+// src/ProjectDashboard/ProjectDashboard.tsx
+import { jsx as jsx32, jsxs as jsxs30 } from "react/jsx-runtime";
+var ProjectDashboard = ({
+  slug,
+  name,
+  totalTasks = 0,
+  doneTasks = 0,
+  completionPercent = 0,
+  statuses = [],
+  epicCount = 0,
+  storyCount = 0,
+  activeTasks = [],
+  tree,
+  loading,
+  onRefresh
+}) => {
+  const [settingsPos, setSettingsPos] = useState18(null);
+  const [contextMenu, setContextMenu] = useState18(null);
+  const [selectedNodeId, setSelectedNodeId] = useState18(null);
+  const selectedTask = useTaskDetailStore((s) => s.selectedTask);
+  const selectTask = useTaskDetailStore((s) => s.selectTask);
+  const clearSelection = useTaskDetailStore((s) => s.clearSelection);
+  const layout = useDashboardStore((s) => s.getLayout(slug));
+  const columns = useDashboardStore((s) => s.getColumns(slug));
+  const moveWidget = useDashboardStore((s) => s.moveWidget);
+  const moveWidgetToIndex = useDashboardStore((s) => s.moveWidgetToIndex);
+  const toggleHidden = useDashboardStore((s) => s.toggleHidden);
+  const toggleLocked = useDashboardStore((s) => s.toggleLocked);
+  const setWidgetColSpan = useDashboardStore((s) => s.setWidgetColSpan);
+  const setColumns = useDashboardStore((s) => s.setColumns);
+  const visibleWidgets = layout.filter((w) => !w.hidden);
+  const handleSettingsToggle = useCallback19((e) => {
+    if (settingsPos) {
+      setSettingsPos(null);
+      return;
+    }
+    const rect = e.currentTarget.getBoundingClientRect();
+    setSettingsPos({ x: rect.right - 260, y: rect.bottom + 6 });
+  }, [settingsPos]);
+  const handleWidgetContextMenu = useCallback19((widgetId, e) => {
+    e.preventDefault();
+    setContextMenu({ x: e.clientX, y: e.clientY, widgetId });
+  }, []);
+  const handleWidgetMove = useCallback19((widgetId, newVisibleIndex) => {
+    const fullLayout = layout;
+    const draggedWidget = fullLayout.find((w) => w.id === widgetId);
+    if (!draggedWidget) return;
+    const visibleOnly = fullLayout.filter((w) => !w.hidden && w.id !== widgetId);
+    const targetIndex = Math.max(0, Math.min(visibleOnly.length, newVisibleIndex));
+    const reorderedVisible = [
+      ...visibleOnly.slice(0, targetIndex),
+      draggedWidget,
+      ...visibleOnly.slice(targetIndex)
+    ];
+    const hiddenWidgets = fullLayout.filter((w) => w.hidden);
+    const newFullLayout = [...reorderedVisible, ...hiddenWidgets];
+    useDashboardStore.getState().updateLayout(slug, newFullLayout);
+  }, [slug, layout]);
+  const handleNodeClick = useCallback19((node) => {
+    if (node.type !== "task" && node.type !== "bug" && node.type !== "hotfix") {
+      setSelectedNodeId(node.id);
+      return;
+    }
+    const treeArray = tree;
+    if (!treeArray) return;
+    for (const epic of treeArray) {
+      if (!epic.children) continue;
+      for (const story of epic.children) {
+        if (!story.children) continue;
+        const task = story.children.find((t) => t.id === node.id);
+        if (task) {
+          setSelectedNodeId(node.id);
+          selectTask({
+            taskId: node.id,
+            epicId: epic.id,
+            storyId: story.id
+          });
+          return;
+        }
+      }
+    }
+  }, [tree, selectTask]);
+  const handleNodeAction = useCallback19(async (actionId, node) => {
+    const treeArray = tree;
+    if (!treeArray) return;
+    let epicId = "";
+    let storyId = "";
+    for (const epic of treeArray) {
+      if (!epic.children) continue;
+      for (const story of epic.children) {
+        if (!story.children) continue;
+        const task = story.children.find((t) => t.id === node.id);
+        if (task) {
+          epicId = epic.id;
+          storyId = story.id;
+          break;
+        }
+      }
+      if (epicId) break;
+    }
+    if (!epicId || !storyId) return;
+    const { mcpCall: mcpCall2 } = await import("./client-YQRASEZG.js");
+    try {
+      switch (actionId) {
+        case "start":
+          await mcpCall2("set_current_task", {
+            project: slug,
+            epic_id: epicId,
+            story_id: storyId,
+            task_id: node.id
+          });
+          onRefresh?.();
+          break;
+        case "complete":
+          await mcpCall2("complete_task", {
+            project: slug,
+            epic_id: epicId,
+            story_id: storyId,
+            task_id: node.id
+          });
+          onRefresh?.();
+          break;
+        case "block":
+          await mcpCall2("update_task", {
+            project: slug,
+            epic_id: epicId,
+            story_id: storyId,
+            task_id: node.id,
+            status: "blocked"
+          });
+          onRefresh?.();
+          break;
+        case "delete":
+          if (confirm(`Delete task "${node.title}"?`)) {
+            await mcpCall2("delete_task", {
+              project: slug,
+              epic_id: epicId,
+              story_id: storyId,
+              task_id: node.id
+            });
+            onRefresh?.();
+          }
+          break;
+      }
+    } catch (error) {
+      console.error("Action failed:", error);
+    }
+  }, [tree, slug, onRefresh]);
+  const renderWidget = useCallback19(
+    (widget) => {
+      switch (widget.type) {
+        case "project-status":
+          return /* @__PURE__ */ jsx32(
+            ProjectStatusWidget,
+            {
+              slug,
+              totalTasks,
+              doneTasks,
+              completionPercent,
+              statuses,
+              epicCount,
+              storyCount,
+              loading,
+              onRefresh
+            }
+          );
+        case "backlog-tree":
+          return /* @__PURE__ */ jsx32(
+            BacklogTreeWidget,
+            {
+              tree: Array.isArray(tree) ? tree : [],
+              totalTasks,
+              doneTasks,
+              loading,
+              selectedNode: selectedNodeId,
+              onNodeClick: handleNodeClick,
+              onNodeAction: handleNodeAction,
+              onFullView: () => {
+                console.log("Full view requested for project:", slug);
+              }
+            }
+          );
+        case "task-distribution":
+          return /* @__PURE__ */ jsx32(
+            TaskDistributionWidget,
+            {
+              byStatus: statuses.map((s) => ({ label: s.label, value: s.count, color: s.color })),
+              byPriority: [],
+              byType: [],
+              loading
+            }
+          );
+        case "recent-activity":
+          return /* @__PURE__ */ jsx32(
+            RecentActivityWidget,
+            {
+              activities: [],
+              loading
+            }
+          );
+        case "sprint-progress":
+          return /* @__PURE__ */ jsx32(
+            SprintProgressWidget,
+            {
+              sprint: null,
+              loading
+            }
+          );
+        case "team-workload":
+          return /* @__PURE__ */ jsx32(
+            TeamWorkloadWidget,
+            {
+              members: [],
+              loading
+            }
+          );
+        case "active-tasks":
+          return /* @__PURE__ */ jsx32(
+            ActiveTasksWidget,
+            {
+              tasks: activeTasks,
+              loading
+            }
+          );
+        case "progress-distribution":
+          return /* @__PURE__ */ jsx32(
+            ProgressDistributionWidget,
+            {
+              data: statuses.map((s) => ({ label: s.label, value: s.count, color: s.color })),
+              completionPercent,
+              loading
+            }
+          );
+        case "session-metrics":
+          return /* @__PURE__ */ jsx32(
+            SessionMetricsWidget,
+            {
+              kpis: []
+            }
+          );
+        case "feature-adoption":
+          return /* @__PURE__ */ jsx32(
+            FeatureAdoptionWidget,
+            {
+              features: []
+            }
+          );
+        default:
+          return /* @__PURE__ */ jsx32("div", { className: "project-dashboard__placeholder", children: WIDGET_TITLES[widget.type] ?? widget.type });
+      }
+    },
+    [slug, totalTasks, doneTasks, completionPercent, statuses, epicCount, storyCount, activeTasks, tree, loading, onRefresh, selectedNodeId, handleNodeClick, handleNodeAction]
+  );
+  return /* @__PURE__ */ jsxs30("div", { className: "project-dashboard", "data-testid": "project-dashboard", children: [
+    /* @__PURE__ */ jsx32(
+      DashboardHeader,
+      {
+        name,
+        onRefresh,
+        onSettingsToggle: handleSettingsToggle
+      }
+    ),
+    /* @__PURE__ */ jsx32("div", { className: "project-dashboard__body", children: /* @__PURE__ */ jsx32(
+      DashboardGrid,
+      {
+        widgets: visibleWidgets,
+        columns,
+        onMoveToIndex: handleWidgetMove,
+        onWidgetContextMenu: handleWidgetContextMenu,
+        renderWidget,
+        className: `project-dashboard__grid--cols-${columns}`
+      }
+    ) }),
+    settingsPos && /* @__PURE__ */ jsx32(
+      DashboardSettings,
+      {
+        x: settingsPos.x,
+        y: settingsPos.y,
+        columns,
+        onColumnsChange: (cols) => setColumns(slug, cols),
+        widgets: layout.map((w) => ({
+          id: w.id,
+          type: w.type,
+          title: WIDGET_TITLES[w.type] ?? w.type,
+          hidden: !!w.hidden
+        })),
+        onWidgetToggle: (id) => toggleHidden(slug, id),
+        onClose: () => setSettingsPos(null)
+      }
+    ),
+    contextMenu && /* @__PURE__ */ jsx32(
+      WidgetContextMenu,
+      {
+        x: contextMenu.x,
+        y: contextMenu.y,
+        widgetId: contextMenu.widgetId,
+        columns,
+        currentColSpan: layout.find((w) => w.id === contextMenu.widgetId)?.colSpan ?? columns,
+        isLocked: layout.find((w) => w.id === contextMenu.widgetId)?.locked,
+        onColSpanChange: (id, colSpan) => setWidgetColSpan(slug, id, colSpan),
+        onHide: (id) => toggleHidden(slug, id),
+        onLock: (id) => toggleLocked(slug, id),
+        onClose: () => setContextMenu(null)
+      }
+    ),
+    /* @__PURE__ */ jsx32(
+      TaskDetailPanel,
+      {
+        isOpen: !!selectedTask,
+        onClose: () => {
+          clearSelection();
+          setSelectedNodeId(null);
+        },
+        params: selectedTask ? {
+          project: slug,
+          epicId: selectedTask.epicId,
+          storyId: selectedTask.storyId,
+          taskId: selectedTask.taskId
+        } : null
+      }
+    )
+  ] });
+};
+
+// src/BacklogTree/BacklogTree.tsx
+import { useState as useState19, useCallback as useCallback20, useEffect as useEffect12 } from "react";
+import { BoxIcon as BoxIcon16 } from "@orchestra-mcp/icons";
+import { EmptyState as EmptyState2 } from "@orchestra-mcp/ui";
+
+// src/BacklogTree/QuickActions.tsx
+import { jsx as jsx33, jsxs as jsxs31 } from "react/jsx-runtime";
+var TERMINAL2 = /* @__PURE__ */ new Set(["done", "cancelled", "rejected"]);
+var STARTABLE2 = /* @__PURE__ */ new Set(["backlog", "todo", "blocked"]);
+var IN_PROGRESS2 = "in-progress";
+function QuickActions({ taskId, status, projectSlug, epicId, storyId, pending, onOptimisticUpdate }) {
+  const { startTask, advanceTask, blockTask, starting, advancing, blocking } = useTaskActions();
+  const loc = {
+    project: projectSlug,
+    epic_id: epicId ?? "",
+    story_id: storyId ?? "",
+    task_id: taskId
+  };
+  const handleClick = (e) => e.stopPropagation();
+  const fireOptimistic = (action) => {
+    const predicted = predictStatus(action, status);
+    if (predicted && onOptimisticUpdate) {
+      onOptimisticUpdate(taskId, predicted);
+    }
+  };
+  const showStart = STARTABLE2.has(status);
+  const showAdvance = status === IN_PROGRESS2 || !TERMINAL2.has(status) && !STARTABLE2.has(status);
+  const showBlock = status === IN_PROGRESS2;
+  const isTerminal = TERMINAL2.has(status);
+  const isDisabled = pending === true;
+  return /* @__PURE__ */ jsxs31("div", { className: `quick-actions${isDisabled ? " quick-actions--disabled" : ""}`, onClick: handleClick, children: [
+    !isTerminal && showStart && /* @__PURE__ */ jsxs31(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Start task",
+        disabled: isDisabled,
+        className: `quick-actions__btn quick-actions__btn--start${starting.loading ? " quick-actions__btn--loading" : ""}`,
+        onClick: () => {
+          fireOptimistic("start");
+          startTask(loc);
+        },
+        children: [
+          starting.loading ? /* @__PURE__ */ jsx33("span", { className: "quick-actions__spinner" }) : "\u25B6",
+          " Start"
+        ]
+      }
+    ),
+    !isTerminal && showAdvance && /* @__PURE__ */ jsxs31(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Advance task",
+        disabled: isDisabled,
+        className: `quick-actions__btn quick-actions__btn--advance${advancing.loading ? " quick-actions__btn--loading" : ""}`,
+        onClick: () => {
+          fireOptimistic("advance");
+          advanceTask(loc, void 0);
+        },
+        children: [
+          advancing.loading ? /* @__PURE__ */ jsx33("span", { className: "quick-actions__spinner" }) : "\u23E9",
+          " Advance"
+        ]
+      }
+    ),
+    !isTerminal && showBlock && /* @__PURE__ */ jsxs31(
+      "button",
+      {
+        type: "button",
+        "aria-label": "Block task",
+        disabled: isDisabled,
+        className: `quick-actions__btn quick-actions__btn--block${blocking.loading ? " quick-actions__btn--loading" : ""}`,
+        onClick: () => {
+          fireOptimistic("block");
+          blockTask(loc);
+        },
+        children: [
+          blocking.loading ? /* @__PURE__ */ jsx33("span", { className: "quick-actions__spinner" }) : "\u26D4",
+          " Block"
+        ]
+      }
+    )
+  ] });
+}
+
+// src/BacklogTree/BacklogTree.tsx
+import { jsx as jsx34, jsxs as jsxs32 } from "react/jsx-runtime";
+var STORAGE_KEY = "orchestra-backlog-expanded";
+function loadExpanded(slug) {
+  try {
+    const raw = localStorage.getItem(`${STORAGE_KEY}:${slug}`);
+    if (raw) return new Set(JSON.parse(raw));
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+function saveExpanded(slug, expanded) {
+  try {
+    localStorage.setItem(`${STORAGE_KEY}:${slug}`, JSON.stringify([...expanded]));
+  } catch {
+  }
+}
+function BacklogTree({ tree, projectSlug, loading, onTaskClick, onTaskSelect, autoExpandIds, pendingTaskIds }) {
+  const [expanded, setExpanded] = useState19(() => loadExpanded(projectSlug));
+  useEffect12(() => {
+    setExpanded(loadExpanded(projectSlug));
+  }, [projectSlug]);
+  useEffect12(() => {
+    if (autoExpandIds && autoExpandIds.size > 0) {
+      setExpanded((prev) => {
+        const next = new Set(prev);
+        for (const id of autoExpandIds) next.add(id);
+        return next;
+      });
+    }
+  }, [autoExpandIds]);
+  const toggle = useCallback20((id) => {
+    setExpanded((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      saveExpanded(projectSlug, next);
+      return next;
+    });
+  }, [projectSlug]);
+  if (loading) {
+    return /* @__PURE__ */ jsx34("div", { className: "backlog-sidebar__loading", children: "Loading..." });
+  }
+  if (tree.length === 0) {
+    return /* @__PURE__ */ jsx34(
+      EmptyState2,
+      {
+        icon: /* @__PURE__ */ jsx34(BoxIcon16, { name: "bx-list-ul", size: 40 }),
+        title: "No epics yet",
+        description: "Create an epic to get started"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx34("div", { className: "backlog-sidebar", "data-testid": "backlog-tree", children: tree.map((epic) => /* @__PURE__ */ jsx34(
+    EpicNode,
+    {
+      node: epic,
+      expanded,
+      onToggle: toggle,
+      onTaskClick,
+      onTaskSelect,
+      projectSlug,
+      pendingTaskIds
+    },
+    epic.id
+  )) });
+}
+function EpicNode({
+  node,
+  expanded,
+  onToggle,
+  onTaskClick,
+  onTaskSelect,
+  projectSlug,
+  pendingTaskIds
+}) {
+  const isOpen = expanded.has(node.id);
+  const stories = node.children ?? [];
+  return /* @__PURE__ */ jsxs32("div", { className: "backlog-sidebar__epic", children: [
+    /* @__PURE__ */ jsxs32(
+      "button",
+      {
+        type: "button",
+        className: "backlog-sidebar__row backlog-sidebar__row--epic",
+        onClick: () => onToggle(node.id),
+        children: [
+          /* @__PURE__ */ jsx34("span", { className: `backlog-sidebar__chevron${isOpen ? " backlog-sidebar__chevron--open" : ""}`, children: "\u25B6" }),
+          /* @__PURE__ */ jsx34("span", { className: "backlog-sidebar__title", children: node.title }),
+          node.priority && /* @__PURE__ */ jsx34(PriorityIcon, { priority: node.priority, size: 12 }),
+          /* @__PURE__ */ jsx34(StatusBadge, { status: node.status, variant: "dot", size: "sm" })
+        ]
+      }
+    ),
+    isOpen && stories.length > 0 && /* @__PURE__ */ jsx34("div", { className: "backlog-sidebar__children", children: stories.map((story) => /* @__PURE__ */ jsx34(
+      StoryNode,
+      {
+        node: story,
+        expanded,
+        onToggle,
+        onTaskClick,
+        onTaskSelect,
+        projectSlug,
+        epicId: node.id,
+        pendingTaskIds
+      },
+      story.id
+    )) })
+  ] });
+}
+function StoryNode({
+  node,
+  expanded,
+  onToggle,
+  onTaskClick,
+  onTaskSelect,
+  projectSlug,
+  epicId,
+  pendingTaskIds
+}) {
+  const isOpen = expanded.has(node.id);
+  const tasks = node.children ?? [];
+  return /* @__PURE__ */ jsxs32("div", { className: "backlog-sidebar__story", children: [
+    /* @__PURE__ */ jsxs32(
+      "button",
+      {
+        type: "button",
+        className: "backlog-sidebar__row backlog-sidebar__row--story",
+        onClick: () => onToggle(node.id),
+        children: [
+          /* @__PURE__ */ jsx34("span", { className: `backlog-sidebar__chevron${isOpen ? " backlog-sidebar__chevron--open" : ""}`, children: "\u25B6" }),
+          /* @__PURE__ */ jsx34("span", { className: "backlog-sidebar__title", children: node.title }),
+          /* @__PURE__ */ jsx34("span", { className: "backlog-sidebar__count", children: tasks.length }),
+          /* @__PURE__ */ jsx34(StatusBadge, { status: node.status, variant: "dot", size: "sm" })
+        ]
+      }
+    ),
+    isOpen && tasks.length > 0 && /* @__PURE__ */ jsx34("div", { className: "backlog-sidebar__children", children: tasks.map((task) => /* @__PURE__ */ jsx34(
+      TaskNode,
+      {
+        node: task,
+        onTaskClick,
+        onTaskSelect,
+        projectSlug,
+        epicId,
+        storyId: node.id,
+        pending: pendingTaskIds?.has(task.id)
+      },
+      task.id
+    )) })
+  ] });
+}
+function getInitials3(name) {
+  return name.split(/[\s-]+/).map((w) => w[0]).join("").toUpperCase().slice(0, 2);
+}
+function TaskNode({
+  node,
+  onTaskClick,
+  onTaskSelect,
+  projectSlug,
+  epicId,
+  storyId,
+  pending
+}) {
+  const wrapClass = `backlog-sidebar__task-wrap${pending ? " backlog-sidebar__task-wrap--pending" : ""}`;
+  return /* @__PURE__ */ jsxs32("div", { className: wrapClass, "data-testid": pending ? `task-pending-${node.id}` : void 0, children: [
+    /* @__PURE__ */ jsxs32(
+      "button",
+      {
+        type: "button",
+        className: "backlog-sidebar__row backlog-sidebar__row--task",
+        onClick: () => {
+          onTaskClick?.(node);
+          onTaskSelect?.(node.id, epicId, storyId);
+        },
+        children: [
+          /* @__PURE__ */ jsx34(StatusBadge, { status: node.status, variant: "dot", size: "sm" }),
+          /* @__PURE__ */ jsx34("span", { className: "backlog-sidebar__title", children: node.title }),
+          node.priority && /* @__PURE__ */ jsx34(PriorityIcon, { priority: node.priority, size: 12 }),
+          node.assignedTo && /* @__PURE__ */ jsx34("span", { className: "backlog-sidebar__assignee", title: node.assignedTo, children: getInitials3(node.assignedTo) })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx34(
+      QuickActions,
+      {
+        taskId: node.id,
+        status: node.status,
+        projectSlug,
+        epicId,
+        storyId,
+        pending
+      }
+    )
+  ] });
+}
+
+// src/TasksSidebar/TasksSidebar.tsx
+import { useState as useState21, useMemo as useMemo6 } from "react";
+
+// src/TaskFilter/TaskFilter.tsx
+import { useState as useState20, useCallback as useCallback21, useEffect as useEffect13, useRef as useRef13 } from "react";
+import { jsx as jsx35, jsxs as jsxs33 } from "react/jsx-runtime";
+var ALL_STATUSES = [
+  "backlog",
+  "todo",
+  "in-progress",
+  "blocked",
+  "ready-for-testing",
+  "in-testing",
+  "ready-for-docs",
+  "in-docs",
+  "documented",
+  "in-review",
+  "done",
+  "rejected",
+  "cancelled"
+];
+var ALL_PRIORITIES = ["critical", "high", "medium", "low"];
+var STATUS_LABELS2 = {
+  backlog: "Backlog",
+  todo: "To Do",
+  "in-progress": "In Progress",
+  blocked: "Blocked",
+  "ready-for-testing": "Ready Test",
+  "in-testing": "Testing",
+  "ready-for-docs": "Ready Docs",
+  "in-docs": "In Docs",
+  documented: "Documented",
+  "in-review": "In Review",
+  done: "Done",
+  rejected: "Rejected",
+  cancelled: "Cancelled"
+};
+var PRIORITY_LABELS = {
+  critical: "Critical",
+  high: "High",
+  medium: "Medium",
+  low: "Low"
+};
+function TaskFilter({ value, onChange, assignees = [] }) {
+  const [open, setOpen] = useState20(null);
+  const ref = useRef13(null);
+  useEffect13(() => {
+    const handler = (e) => {
+      if (ref.current && !ref.current.contains(e.target)) {
+        setOpen(null);
+      }
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, []);
+  const toggleDropdown = useCallback21((key) => {
+    setOpen((prev) => prev === key ? null : key);
+  }, []);
+  const toggleStatus = useCallback21((status) => {
+    const next = value.statuses.includes(status) ? value.statuses.filter((s) => s !== status) : [...value.statuses, status];
+    onChange({ ...value, statuses: next });
+  }, [value, onChange]);
+  const togglePriority = useCallback21((priority) => {
+    const next = value.priorities.includes(priority) ? value.priorities.filter((p) => p !== priority) : [...value.priorities, priority];
+    onChange({ ...value, priorities: next });
+  }, [value, onChange]);
+  const setAssignee = useCallback21((assignee) => {
+    onChange({ ...value, assignee });
+    setOpen(null);
+  }, [value, onChange]);
+  const clearAll = useCallback21(() => {
+    onChange({ statuses: [], priorities: [], assignee: "", searchQuery: "" });
+  }, [onChange]);
+  const selectAllStatuses = useCallback21(() => {
+    onChange({ ...value, statuses: [...ALL_STATUSES] });
+  }, [value, onChange]);
+  const clearStatuses = useCallback21(() => {
+    onChange({ ...value, statuses: [] });
+  }, [value, onChange]);
+  const onSearchChange = useCallback21((e) => {
+    onChange({ ...value, searchQuery: e.target.value });
+  }, [value, onChange]);
+  const clearSearch = useCallback21(() => {
+    onChange({ ...value, searchQuery: "" });
+  }, [value, onChange]);
+  const hasFilters = value.statuses.length > 0 || value.priorities.length > 0 || value.assignee !== "" || value.searchQuery !== "";
+  return /* @__PURE__ */ jsxs33("div", { className: "task-filter", ref, "data-testid": "task-filter", children: [
+    /* @__PURE__ */ jsxs33("div", { className: "task-filter__search-wrap", children: [
+      /* @__PURE__ */ jsx35(
+        "input",
+        {
+          className: "task-filter__search",
+          type: "text",
+          placeholder: "Search tasks...",
+          value: value.searchQuery,
+          onChange: onSearchChange,
+          "data-testid": "task-filter-search"
+        }
+      ),
+      value.searchQuery && /* @__PURE__ */ jsx35(
+        "button",
+        {
+          type: "button",
+          className: "task-filter__search-clear",
+          onClick: clearSearch,
+          "aria-label": "Clear search",
+          children: "\xD7"
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs33(
+      FilterDropdown,
+      {
+        label: "Status",
+        count: value.statuses.length,
+        isOpen: open === "status",
+        onToggle: () => toggleDropdown("status"),
+        children: [
+          /* @__PURE__ */ jsxs33("div", { className: "task-filter__actions", children: [
+            /* @__PURE__ */ jsx35("button", { type: "button", className: "task-filter__action-btn", onClick: selectAllStatuses, children: "Select All" }),
+            /* @__PURE__ */ jsx35("button", { type: "button", className: "task-filter__action-btn", onClick: clearStatuses, children: "Clear" })
+          ] }),
+          ALL_STATUSES.map((s) => /* @__PURE__ */ jsx35(
+            CheckboxOption,
+            {
+              label: STATUS_LABELS2[s] ?? s,
+              checked: value.statuses.includes(s),
+              onChange: () => toggleStatus(s)
+            },
+            s
+          ))
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx35(
+      FilterDropdown,
+      {
+        label: "Priority",
+        count: value.priorities.length,
+        isOpen: open === "priority",
+        onToggle: () => toggleDropdown("priority"),
+        children: ALL_PRIORITIES.map((p) => /* @__PURE__ */ jsx35(
+          CheckboxOption,
+          {
+            label: PRIORITY_LABELS[p] ?? p,
+            checked: value.priorities.includes(p),
+            onChange: () => togglePriority(p)
+          },
+          p
+        ))
+      }
+    ),
+    /* @__PURE__ */ jsxs33(
+      FilterDropdown,
+      {
+        label: "Assignee",
+        count: value.assignee ? 1 : 0,
+        isOpen: open === "assignee",
+        onToggle: () => toggleDropdown("assignee"),
+        children: [
+          /* @__PURE__ */ jsx35(
+            "button",
+            {
+              type: "button",
+              className: `task-filter__option${value.assignee === "" ? " task-filter__option--selected" : ""}`,
+              onClick: () => setAssignee(""),
+              children: "All"
+            }
+          ),
+          assignees.map((a) => /* @__PURE__ */ jsx35(
+            "button",
+            {
+              type: "button",
+              className: `task-filter__option${value.assignee === a ? " task-filter__option--selected" : ""}`,
+              onClick: () => setAssignee(a),
+              children: a
+            },
+            a
+          ))
+        ]
+      }
+    ),
+    hasFilters && /* @__PURE__ */ jsx35("button", { type: "button", className: "task-filter__clear", onClick: clearAll, children: "Clear all" })
+  ] });
+}
+function FilterDropdown({
+  label,
+  count,
+  isOpen,
+  onToggle,
+  children
+}) {
+  return /* @__PURE__ */ jsxs33("div", { className: "task-filter__dropdown-wrap", children: [
+    /* @__PURE__ */ jsxs33(
+      "button",
+      {
+        type: "button",
+        className: `task-filter__trigger${isOpen ? " task-filter__trigger--active" : ""}`,
+        onClick: onToggle,
+        "data-testid": `filter-trigger-${label.toLowerCase()}`,
+        children: [
+          label,
+          count > 0 && /* @__PURE__ */ jsx35("span", { className: "task-filter__count", children: count })
+        ]
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsx35("div", { className: "task-filter__dropdown", "data-testid": `filter-dropdown-${label.toLowerCase()}`, children })
+  ] });
+}
+function CheckboxOption({
+  label,
+  checked,
+  onChange
+}) {
+  return /* @__PURE__ */ jsxs33("button", { type: "button", className: "task-filter__option", onClick: onChange, children: [
+    /* @__PURE__ */ jsx35("span", { className: `task-filter__checkbox${checked ? " task-filter__checkbox--checked" : ""}`, children: checked ? "\u2713" : "" }),
+    label
+  ] });
+}
+
+// src/ConnectionStatus/ConnectionStatus.tsx
+import { jsx as jsx36, jsxs as jsxs34 } from "react/jsx-runtime";
+var STATUS_LABELS3 = {
+  connected: "Connected",
+  reconnecting: "Reconnecting...",
+  disconnected: "Connection lost"
+};
+var BANNER_TEXT = {
+  reconnecting: "Reconnecting to server...",
+  disconnected: "Connection lost. Click refresh to retry."
+};
+var ConnectionStatus = ({ status }) => {
+  const label = STATUS_LABELS3[status];
+  const bannerText = BANNER_TEXT[status];
+  return /* @__PURE__ */ jsxs34("div", { className: "connection-status", "data-testid": "connection-status", children: [
+    /* @__PURE__ */ jsx36(
+      "span",
+      {
+        className: `connection-status__dot connection-status__dot--${status}`,
+        title: label,
+        "aria-label": label,
+        role: "status"
+      }
+    ),
+    bannerText && /* @__PURE__ */ jsx36(
+      "div",
+      {
+        className: `connection-status__banner connection-status__banner--${status}`,
+        role: "alert",
+        "data-testid": "connection-status-banner",
+        children: bannerText
+      }
+    )
+  ] });
+};
+var ConnectionStatusDot = ({ status }) => {
+  const label = STATUS_LABELS3[status];
+  return /* @__PURE__ */ jsx36(
+    "span",
+    {
+      className: `connection-status__dot connection-status__dot--${status}`,
+      title: label,
+      "aria-label": label,
+      role: "status",
+      "data-testid": "connection-status-dot"
+    }
+  );
+};
+var ConnectionStatusBanner = ({ status }) => {
+  const bannerText = BANNER_TEXT[status];
+  if (!bannerText) return null;
+  return /* @__PURE__ */ jsx36(
+    "div",
+    {
+      className: `connection-status__banner connection-status__banner--${status}`,
+      role: "alert",
+      "data-testid": "connection-status-banner",
+      children: bannerText
+    }
+  );
+};
+
+// src/TasksSidebar/TasksSidebar.tsx
+import { jsx as jsx37, jsxs as jsxs35 } from "react/jsx-runtime";
+var INITIAL_FILTERS = { statuses: [], priorities: [], assignee: "", searchQuery: "" };
+function TasksSidebar({
+  projectName,
+  projectSlug,
+  tree,
+  loading,
+  connectionStatus,
+  onBack,
+  onTaskClick,
+  onTaskSelect,
+  onRefresh
+}) {
+  const [filters, setFilters] = useState21(INITIAL_FILTERS);
+  const debouncedQuery = useDebounce(filters.searchQuery, 300);
+  const debouncedFilters = useMemo6(
+    () => ({ ...filters, searchQuery: debouncedQuery }),
+    [filters, debouncedQuery]
+  );
+  const filteredTree = useFilteredTree(tree, debouncedFilters);
+  const autoExpandIds = useMemo6(
+    () => collectMatchParentIds(tree, debouncedQuery),
+    [tree, debouncedQuery]
+  );
+  const assignees = extractAssignees(tree);
+  return /* @__PURE__ */ jsxs35("div", { className: "tasks-sidebar", "data-testid": "tasks-sidebar", children: [
+    /* @__PURE__ */ jsxs35("div", { className: "tasks-sidebar__header", children: [
+      onBack && /* @__PURE__ */ jsx37(
+        "button",
+        {
+          type: "button",
+          className: "tasks-sidebar__back",
+          onClick: onBack,
+          "aria-label": "Back to projects",
+          children: "\u2190"
+        }
+      ),
+      /* @__PURE__ */ jsx37("span", { className: "tasks-sidebar__project-name", children: projectName }),
+      connectionStatus && /* @__PURE__ */ jsx37(ConnectionStatusDot, { status: connectionStatus }),
+      onRefresh && /* @__PURE__ */ jsx37(
+        "button",
+        {
+          type: "button",
+          className: "tasks-sidebar__refresh",
+          onClick: onRefresh,
+          "aria-label": "Refresh",
+          children: "\u21BB"
+        }
+      )
+    ] }),
+    connectionStatus && /* @__PURE__ */ jsx37(ConnectionStatusBanner, { status: connectionStatus }),
+    /* @__PURE__ */ jsx37(TaskFilter, { value: filters, onChange: setFilters, assignees }),
+    /* @__PURE__ */ jsx37(
+      BacklogTree,
+      {
+        tree: filteredTree,
+        projectSlug,
+        loading,
+        onTaskClick,
+        onTaskSelect,
+        autoExpandIds
+      }
+    )
+  ] });
+}
+
+// src/LifecycleProgressBar/LifecycleProgressBar.tsx
+import React from "react";
+import { jsx as jsx38, jsxs as jsxs36 } from "react/jsx-runtime";
+var LIFECYCLE_STEPS = [
+  { key: "backlog", label: "Backlog", color: "#6b7280" },
+  { key: "todo", label: "To Do", color: "#3b82f6" },
+  { key: "in-progress", label: "In Progress", color: "#8b5cf6" },
+  { key: "ready-for-testing", label: "Ready for Testing", color: "#f59e0b" },
+  { key: "in-testing", label: "In Testing", color: "#f97316" },
+  { key: "ready-for-docs", label: "Ready for Docs", color: "#06b6d4" },
+  { key: "in-docs", label: "In Docs", color: "#0ea5e9" },
+  { key: "documented", label: "Documented", color: "#14b8a6" },
+  { key: "in-review", label: "In Review", color: "#a855f7" },
+  { key: "done", label: "Done", color: "#22c55e" }
+];
+var SPECIAL_STATUSES = {
+  blocked: { label: "Blocked", color: "#ef4444" },
+  rejected: { label: "Rejected", color: "#ef4444" },
+  cancelled: { label: "Cancelled", color: "#6b7280" }
+};
+function getDotState(stepIndex, currentIndex, isSpecial) {
+  if (isSpecial) return "future";
+  if (stepIndex < currentIndex) return "past";
+  if (stepIndex === currentIndex) return "current";
+  return "future";
+}
+function getLineState(lineIndex, currentIndex, isSpecial) {
+  if (isSpecial) return "future";
+  if (lineIndex < currentIndex) return "past";
+  return "future";
+}
+function LifecycleProgressBar({ status, size = "sm" }) {
+  const isSpecial = status in SPECIAL_STATUSES;
+  const specialInfo = isSpecial ? SPECIAL_STATUSES[status] : null;
+  const currentIndex = LIFECYCLE_STEPS.findIndex((s) => s.key === status);
+  return /* @__PURE__ */ jsxs36("div", { className: `lifecycle-bar lifecycle-bar--${size}`, "data-testid": "lifecycle-bar", children: [
+    /* @__PURE__ */ jsx38("div", { className: "lifecycle-bar__track", children: LIFECYCLE_STEPS.map((step, i) => {
+      const dotState = getDotState(i, currentIndex, isSpecial);
+      const dotColor = dotState === "future" ? void 0 : step.color;
+      return /* @__PURE__ */ jsxs36(React.Fragment, { children: [
+        i > 0 && /* @__PURE__ */ jsx38(
+          "div",
+          {
+            className: `lifecycle-bar__line lifecycle-bar__line--${getLineState(i, currentIndex, isSpecial)}`,
+            "data-testid": `line-${i}`
+          }
+        ),
+        /* @__PURE__ */ jsx38(
+          "div",
+          {
+            className: `lifecycle-bar__dot lifecycle-bar__dot--${dotState}`,
+            style: dotColor ? { backgroundColor: dotColor, color: dotColor } : void 0,
+            title: step.label,
+            "data-testid": `step-${step.key}`
+          }
+        )
+      ] }, step.key);
+    }) }),
+    isSpecial && specialInfo && /* @__PURE__ */ jsx38(
+      "div",
+      {
+        className: "lifecycle-bar__special",
+        style: { color: specialInfo.color },
+        "data-testid": "special-status",
+        children: specialInfo.label
+      }
+    )
+  ] });
+}
+export {
+  ActiveTasksWidget,
+  BacklogTree,
+  BacklogTreeWidget,
+  BacklogView,
+  ConnectionStatus,
+  ConnectionStatusBanner,
+  ConnectionStatusDot,
+  DashboardGrid,
+  DashboardHeader,
+  DashboardSettings,
+  DetailPanel,
+  EditableSelect,
+  EditableText,
+  EditableTextarea,
+  EvidenceLog,
+  FeatureAdoptionWidget,
+  LabelsSection,
+  LifecycleProgressBar,
+  LinksSection,
+  PriorityIcon,
+  ProgressDistributionWidget,
+  ProjectDashboard,
+  ProjectItem,
+  ProjectStatusWidget,
+  ProjectsSidebar,
+  RecentActivityWidget,
+  ResizeHandle,
+  SessionMetricsWidget,
+  SprintProgressWidget,
+  StaleNotification,
+  StatusActions,
+  StatusBadge,
+  StatusGrid,
+  TaskDetailPanel,
+  TaskDistributionWidget,
+  TaskFilter,
+  TaskList,
+  TasksSidebar,
+  TeamWorkloadWidget,
+  WidgetContextMenu,
+  extractAssignees,
+  mcpCall,
+  predictStatus,
+  useConnectionStatus,
+  useDashboardStore,
+  useFilteredTree,
+  useGridDrag,
+  useIntegrationStore,
+  useOptimisticTaskActions,
+  useProjectTree,
+  useProjects,
+  useTaskActions,
+  useTaskDetail,
+  useTaskDetailStore
+};