@nextop-os/workspace-issue-manager 0.0.18 → 0.0.20

package/dist/chunk-XI6VLBSW.js

@@ -0,0 +1,4391 @@
+import {
+  applyIssueManagerIssueDeleted,
+  applyIssueManagerIssueEditorModeToNodeState,
+  applyIssueManagerIssueSaved,
+  applyIssueManagerIssueSelection,
+  applyIssueManagerSelectedAgentProvider,
+  applyIssueManagerTaskDeleted,
+  applyIssueManagerTaskEditorModeToNodeState,
+  applyIssueManagerTaskSaved,
+  applyIssueManagerTaskSelection,
+  confirmIssueManagerMessage,
+  createIssueManagerControllerService,
+  createIssueManagerIssueDraftFromNodeState,
+  createIssueManagerTaskDraftFromNodeState,
+  defaultTaskPriority,
+  formatIssueManagerDate,
+  formatIssueManagerTimestamp,
+  persistIssueManagerIssueDraftContent,
+  persistIssueManagerIssueDraftTitle,
+  persistIssueManagerTaskDraftContent,
+  persistIssueManagerTaskDraftTitle,
+  resolveIssueManagerErrorMessage,
+  resolveIssueManagerPriorityLabel,
+  resolveIssueManagerStatusLabel,
+  toContextRefInput,
+  toIssueManagerWorkspaceFileLinkInput,
+  uniqueIssueManagerFileReferences
+} from "./chunk-ZWDF5XA7.js";
+import {
+  appendIssueManagerWorkspaceFileLinksToContent,
+  clampIssueManagerSidebarWidth,
+  extractIssueManagerPlainTextFromContent,
+  extractIssueManagerWorkspaceFileLinksFromContent,
+  issueManagerSidebarDefaultWidth,
+  issueManagerSidebarMaxWidth,
+  issueManagerSidebarMinWidth,
+  normalizeIssueManagerContent,
+  shouldAutoCollapseIssueManagerSidebar
+} from "./chunk-V75TAM27.js";
+
+// src/ui/react/internal/shell/IssueManagerNodeState.ts
+import { useEffect, useEffectEvent, useState } from "react";
+var issueManagerTaskListCollapsedEvent = "nextop:issue-manager-task-list-collapsed";
+function dispatchIssueManagerTaskListCollapsed(input) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.dispatchEvent(
+    new CustomEvent(
+      issueManagerTaskListCollapsedEvent,
+      {
+        detail: input
+      }
+    )
+  );
+}
+function useIssueManagerTaskListCollapsedSync(input) {
+  const onCollapsedChange = useEffectEvent(input.onCollapsedChange);
+  useEffect(() => {
+    if (typeof window === "undefined") {
+      return void 0;
+    }
+    const handleTaskListCollapsedChange = (event) => {
+      const detail = event.detail;
+      if (detail?.nodeId !== input.nodeId) {
+        return;
+      }
+      onCollapsedChange(detail.collapsed);
+    };
+    window.addEventListener(
+      issueManagerTaskListCollapsedEvent,
+      handleTaskListCollapsedChange
+    );
+    return () => {
+      window.removeEventListener(
+        issueManagerTaskListCollapsedEvent,
+        handleTaskListCollapsedChange
+      );
+    };
+  }, [input.nodeId, onCollapsedChange]);
+}
+function useIssueManagerNodeHeaderView(input) {
+  const [manualCollapsed, setManualCollapsed] = useState(
+    input.isSidebarCollapsed
+  );
+  useEffect(() => {
+    setManualCollapsed(input.isSidebarCollapsed);
+  }, [input.isSidebarCollapsed]);
+  useIssueManagerTaskListCollapsedSync({
+    nodeId: input.nodeId,
+    onCollapsedChange: setManualCollapsed
+  });
+  const effectiveCollapsed = input.isSidebarAutoCollapsed || manualCollapsed;
+  return {
+    effectiveCollapsed,
+    toggleLabel: effectiveCollapsed ? input.copy.t("actions.expandIssueList") : input.copy.t("actions.collapseIssueList"),
+    toggleSidebar: () => {
+      input.onToggleSidebar(!effectiveCollapsed);
+    }
+  };
+}
+function resolveIssueManagerSelectedIssue(input) {
+  if (!input.selectedIssueId) {
+    return null;
+  }
+  return input.issueDetail ?? input.issues.find((issue) => issue.issueId === input.selectedIssueId) ?? null;
+}
+function resolveIssueManagerSelectedTask(input) {
+  if (!input.selectedTaskId) {
+    return null;
+  }
+  return input.taskDetail ?? input.tasks.find((task) => task.taskId === input.selectedTaskId) ?? null;
+}
+
+// src/ui/react/internal/reference/IssueManagerReferencePickerState.ts
+function normalizeDirectoryPath(path) {
+  if (!path || path === "/") {
+    return "/";
+  }
+  return path.replace(/\/+$/, "") || "/";
+}
+function collectVisibleTreeEntries(entries, directoryStateByPath, expandedFolderPaths) {
+  const collected = [];
+  for (const entry of entries) {
+    collected.push(entry);
+    if (entry.kind !== "folder") {
+      continue;
+    }
+    const folderKey = normalizeDirectoryPath(entry.path);
+    if (!expandedFolderPaths[folderKey]) {
+      continue;
+    }
+    const childEntries = directoryStateByPath[folderKey]?.entries ?? [];
+    if (childEntries.length === 0) {
+      continue;
+    }
+    collected.push(
+      ...collectVisibleTreeEntries(
+        childEntries,
+        directoryStateByPath,
+        expandedFolderPaths
+      )
+    );
+  }
+  return collected;
+}
+function createReferenceDirectoryStateFromSnapshot(snapshot) {
+  const stateByPath = {};
+  addReferenceDirectoryStateFromSnapshot(stateByPath, snapshot.directory);
+  return stateByPath;
+}
+function addReferenceDirectoryStateFromSnapshot(stateByPath, directory) {
+  const normalizedPath = normalizeDirectoryPath(directory.directoryPath);
+  stateByPath[normalizedPath] = {
+    displayPath: directory.directoryPath,
+    entries: directory.entries.map((entry) => ({
+      displayName: entry.displayName,
+      kind: entry.kind,
+      path: entry.path
+    })),
+    loaded: true,
+    loading: false,
+    prefetchReason: directory.prefetchReason,
+    prefetchState: directory.prefetchState
+  };
+  for (const entry of directory.entries) {
+    if (entry.kind !== "folder") {
+      continue;
+    }
+    const folderKey = normalizeDirectoryPath(entry.path);
+    if (entry.prefetchedDirectory) {
+      addReferenceDirectoryStateFromSnapshot(
+        stateByPath,
+        entry.prefetchedDirectory
+      );
+      continue;
+    }
+    if (entry.prefetchState) {
+      stateByPath[folderKey] = {
+        displayPath: entry.path,
+        entries: [],
+        loaded: false,
+        loading: false,
+        prefetchReason: entry.prefetchReason,
+        prefetchState: entry.prefetchState
+      };
+    }
+  }
+}
+
+// src/ui/react/internal/controller/useIssueManagerController.ts
+import { useMemo as useMemo2 } from "react";
+
+// src/ui/react/internal/controller/IssueManagerControllerCapabilities.ts
+var issueManagerProviderOptions = ["codex"];
+function resolveIssueManagerControllerCapabilities(feature) {
+  return {
+    canInviteCollaborators: feature.ui.showInviteCollaborator === true && typeof feature.shareAdapter?.createIssueLink === "function",
+    canReferenceWorkspaceFiles: hasFileAdapterMethod(feature.fileAdapter, "requestReferences") || hasFileAdapterMethod(feature.fileAdapter, "loadReferenceTree") || hasFileAdapterMethod(feature.fileAdapter, "listDirectory") || hasFileAdapterMethod(feature.fileAdapter, "searchReferences"),
+    canUploadWorkspaceFiles: hasFileAdapterMethod(
+      feature.fileAdapter,
+      "requestUpload"
+    )
+  };
+}
+function hasFileAdapterMethod(fileAdapter, methodName) {
+  return typeof Reflect.get(fileAdapter ?? {}, methodName) === "function";
+}
+
+// src/services/internal/controllerOutcomes.ts
+function applyIssueManagerControllerOutcome(input) {
+  if (input.outcome.notificationKey) {
+    input.notify(input.translate(input.outcome.notificationKey));
+  }
+  if (input.outcome.issueDraft) {
+    input.setIssueDraftInternal(input.outcome.issueDraft);
+  }
+  if (input.outcome.issueEditorMode) {
+    input.setIssueEditorModeState(input.outcome.issueEditorMode);
+  }
+  if ("referenceTarget" in input.outcome) {
+    input.setReferenceTarget(input.outcome.referenceTarget ?? null);
+  }
+  if (input.outcome.taskDraft) {
+    input.setTaskDraftInternal(input.outcome.taskDraft);
+  }
+  if (input.outcome.taskEditorMode) {
+    input.setTaskEditorModeState(input.outcome.taskEditorMode);
+  }
+  if (input.outcome.nodeState) {
+    input.updateNodeState(input.outcome.nodeState);
+  }
+  if (input.outcome.refreshAll) {
+    input.refreshAll();
+  }
+  if (input.outcome.refreshDetails) {
+    input.refreshDetails();
+  }
+}
+function createIssueManagerRunTaskSuccessOutcome(input) {
+  return {
+    notificationKey: input.status === "completed" ? void 0 : "messages.runFailed"
+  };
+}
+function createIssueManagerSaveIssueSuccessOutcome(issueId) {
+  return {
+    issueEditorMode: "read",
+    nodeState: (current) => applyIssueManagerIssueSaved(current, issueId),
+    refreshAll: true
+  };
+}
+function createIssueManagerSaveTaskSuccessOutcome(taskId) {
+  return {
+    nodeState: (current) => applyIssueManagerTaskSaved(current, taskId),
+    refreshAll: true,
+    taskEditorMode: "read"
+  };
+}
+
+// src/services/internal/reference/controllerReferenceCommands.ts
+function canIssueManagerRequestReferencesDirectly(fileAdapter) {
+  return Boolean(
+    fileAdapter?.requestReferences && !fileAdapter.loadReferenceTree && !fileAdapter.listDirectory && !fileAdapter.searchReferences
+  );
+}
+async function executeIssueManagerRequestReferences(input) {
+  return input.fileAdapter.requestReferences({
+    workspaceId: input.workspaceId
+  });
+}
+function canIssueManagerUploadReferences(fileAdapter) {
+  return typeof fileAdapter?.requestUpload === "function";
+}
+function canIssueManagerOpenReferences(fileAdapter) {
+  return typeof fileAdapter?.openReference === "function";
+}
+async function executeIssueManagerUploadReferences(input) {
+  const refs = await input.fileAdapter.requestUpload({
+    mode: input.mode,
+    targetDirectoryPath: "/",
+    workspaceId: input.workspaceId
+  });
+  if (refs.length === 0) {
+    return refs;
+  }
+  await input.fileAdapter.refreshTree?.({
+    depth: 1,
+    paths: refs.map((ref) => ref.path),
+    workspaceId: input.workspaceId
+  });
+  return refs;
+}
+function resolveIssueManagerReferenceInsertionContent(input) {
+  const preparedRefs = prepareIssueManagerReferences(input.refs);
+  if (preparedRefs.length === 0) {
+    return input.content;
+  }
+  return appendIssueManagerWorkspaceFileLinksToContent(
+    input.content,
+    preparedRefs.map(toIssueManagerWorkspaceFileLinkInput)
+  );
+}
+async function executeIssueManagerAttachReferences(input) {
+  const preparedRefs = prepareIssueManagerReferences(input.refs);
+  if (!input.target || preparedRefs.length === 0 || !input.selectedIssueId) {
+    return false;
+  }
+  await input.backend.addContextRefs(
+    input.target.parentKind === "task" ? {
+      issueId: input.selectedIssueId,
+      parentKind: "task",
+      refs: preparedRefs.map(toContextRefInput),
+      taskId: input.target.taskId,
+      workspaceId: input.workspaceId
+    } : {
+      issueId: input.selectedIssueId,
+      parentKind: "issue",
+      refs: preparedRefs.map(toContextRefInput),
+      workspaceId: input.workspaceId
+    }
+  );
+  return true;
+}
+async function executeIssueManagerOpenReference(input) {
+  await input.fileAdapter.openReference(input.reference);
+}
+async function executeIssueManagerRemoveContextRef(input) {
+  await input.backend.removeContextRef(
+    input.ref.parentKind === "task" ? {
+      contextRefId: input.ref.contextRefId,
+      issueId: input.ref.issueId,
+      parentKind: "task",
+      taskId: input.ref.taskId,
+      workspaceId: input.workspaceId
+    } : {
+      contextRefId: input.ref.contextRefId,
+      issueId: input.ref.issueId,
+      parentKind: "issue",
+      workspaceId: input.workspaceId
+    }
+  );
+}
+function prepareIssueManagerReferences(refs) {
+  return refs.filter((ref) => ref.path.trim().length > 0);
+}
+
+// src/services/internal/reference/controllerReferenceOutcomes.ts
+function createIssueManagerOpenReferencePickerOutcome(target) {
+  return {
+    referenceTarget: target
+  };
+}
+function createIssueManagerAttachReferencesOutcome(attached) {
+  return {
+    referenceTarget: null,
+    refreshDetails: attached
+  };
+}
+function createIssueManagerInsertReferencesOutcome(input) {
+  return input.target.parentKind === "issue" ? {
+    issueDraft: (current) => ({
+      ...current,
+      content: resolveIssueManagerReferenceInsertionContent({
+        content: current.content,
+        refs: input.refs
+      })
+    }),
+    referenceTarget: null
+  } : {
+    referenceTarget: null,
+    taskDraft: (current) => ({
+      ...current,
+      content: resolveIssueManagerReferenceInsertionContent({
+        content: current.content,
+        refs: input.refs
+      })
+    })
+  };
+}
+
+// src/services/internal/controllerPlans.ts
+function createIssueManagerRunTaskPlan(input) {
+  if (!input.issueDetail || !input.taskDetail) {
+    return { kind: "skip" };
+  }
+  const provider = input.providerOverride?.trim() || input.selectedAgentProvider.trim();
+  if (!provider) {
+    return { kind: "skip" };
+  }
+  return {
+    kind: "ready",
+    provider,
+    shouldUpdateSelectedAgentProvider: provider !== input.selectedAgentProvider
+  };
+}
+function createIssueManagerSaveIssuePlan(input) {
+  const title = input.issueDraft.title.trim();
+  if (!title) {
+    return {
+      kind: "blocked",
+      notificationKey: "messages.titleRequired"
+    };
+  }
+  return { kind: "ready" };
+}
+function createIssueManagerSaveTaskPlan(input) {
+  if (!input.selectedIssueId) {
+    return { kind: "skip" };
+  }
+  const title = input.taskDraft.title.trim();
+  if (!title) {
+    return {
+      kind: "blocked",
+      notificationKey: "messages.titleRequired"
+    };
+  }
+  return {
+    kind: "ready",
+    selectedIssueId: input.selectedIssueId
+  };
+}
+
+// src/services/internal/reference/controllerReferencePlans.ts
+function createIssueManagerAttachReferenceTarget(parentKind, selectedTaskId) {
+  return parentKind === "task" ? {
+    mode: "attach",
+    parentKind: "task",
+    taskId: selectedTaskId ?? ""
+  } : {
+    mode: "attach",
+    parentKind: "issue"
+  };
+}
+function createIssueManagerInsertReferenceTarget(parentKind, selectedTaskId) {
+  return parentKind === "task" ? {
+    mode: "insert",
+    parentKind: "task",
+    taskId: selectedTaskId ?? ""
+  } : {
+    mode: "insert",
+    parentKind: "issue"
+  };
+}
+function createIssueManagerAttachReferencesPlan(input) {
+  if (!input.hasFileAdapter) {
+    return { kind: "skip" };
+  }
+  if (input.parentKind === "task" && !input.selectedTaskId) {
+    return { kind: "skip" };
+  }
+  const target = createIssueManagerAttachReferenceTarget(
+    input.parentKind,
+    input.selectedTaskId
+  );
+  return input.requestReferencesDirectly ? { kind: "request_directly", target } : { kind: "open_picker", target };
+}
+function createIssueManagerInsertReferencesPlan(input) {
+  if (!input.hasFileAdapter) {
+    return { kind: "skip" };
+  }
+  if (input.parentKind === "task" && !input.selectedTaskId && input.taskEditorMode !== "create") {
+    return { kind: "skip" };
+  }
+  const target = createIssueManagerInsertReferenceTarget(
+    input.parentKind,
+    input.selectedTaskId
+  );
+  return input.requestReferencesDirectly ? { kind: "request_directly", target } : { kind: "open_picker", target };
+}
+
+// src/services/internal/run/controllerRunCommands.ts
+async function executeIssueManagerRunTask(input) {
+  const currentUser = await Promise.resolve(
+    input.feature.identityAdapter.currentUser()
+  );
+  const createdRun = await input.feature.backend.createRun({
+    agentProvider: input.provider,
+    agentUserId: currentUser?.userId ?? void 0,
+    issueId: input.issue.issueId,
+    taskId: input.task.taskId,
+    workspaceId: input.workspaceId
+  });
+  await input.onCreatedRun?.(createdRun);
+  try {
+    const result = await input.feature.agentRunner.runTask({
+      issue: input.issue,
+      provider: input.provider,
+      run: createdRun,
+      task: input.task,
+      workspaceId: input.workspaceId
+    });
+    await input.feature.backend.completeRun({
+      errorMessage: result.errorMessage,
+      issueId: input.issue.issueId,
+      outputs: result.outputs ?? [],
+      runId: createdRun.runId,
+      status: result.status,
+      summary: result.summary,
+      taskId: input.task.taskId,
+      workspaceId: input.workspaceId
+    });
+    return {
+      createdRun,
+      status: result.status
+    };
+  } catch (error) {
+    try {
+      await input.feature.backend.completeRun({
+        errorMessage: String(error instanceof Error ? error.message : error),
+        issueId: input.issue.issueId,
+        outputs: [],
+        runId: createdRun.runId,
+        status: "failed",
+        summary: input.copy.t("run.failedSummaryFallback"),
+        taskId: input.task.taskId,
+        workspaceId: input.workspaceId
+      });
+    } catch {
+    }
+    throw error;
+  }
+}
+
+// src/services/internal/save/controllerSaveCommands.ts
+async function executeIssueManagerSaveIssue(input) {
+  const content = normalizeIssueManagerContent(input.issueDraft.content);
+  const savedIssue = input.issueEditorMode === "create" ? await input.feature.backend.createIssue({
+    content,
+    title: input.issueDraft.title.trim(),
+    workspaceId: input.workspaceId
+  }) : await input.feature.backend.updateIssue({
+    content,
+    issueId: input.selectedIssueId ?? "",
+    title: input.issueDraft.title.trim(),
+    workspaceId: input.workspaceId
+  });
+  await syncIssueManagerContentReferences({
+    backend: input.feature.backend,
+    content,
+    existingRefs: input.issueEditorMode === "create" ? [] : input.issueDetail?.contextRefs.filter(
+      (ref) => ref.parentKind === "issue"
+    ) ?? [],
+    issueId: savedIssue.issueId,
+    parentKind: "issue",
+    workspaceId: input.workspaceId
+  });
+  return {
+    content,
+    savedIssue
+  };
+}
+async function executeIssueManagerSaveTask(input) {
+  const content = normalizeIssueManagerContent(input.taskDraft.content);
+  const savedTask = input.taskEditorMode === "create" ? await input.feature.backend.createTask({
+    content,
+    issueId: input.selectedIssueId,
+    priority: input.taskDraft.priority,
+    title: input.taskDraft.title.trim(),
+    workspaceId: input.workspaceId
+  }) : await input.feature.backend.updateTask({
+    content,
+    issueId: input.selectedIssueId,
+    priority: input.taskDraft.priority,
+    taskId: input.selectedTaskId ?? "",
+    title: input.taskDraft.title.trim(),
+    workspaceId: input.workspaceId
+  });
+  await syncIssueManagerContentReferences({
+    backend: input.feature.backend,
+    content,
+    existingRefs: input.taskEditorMode === "create" ? [] : input.taskDetail?.contextRefs.filter(
+      (ref) => ref.parentKind === "task"
+    ) ?? [],
+    issueId: input.selectedIssueId,
+    parentKind: "task",
+    taskId: savedTask.taskId,
+    workspaceId: input.workspaceId
+  });
+  return {
+    content,
+    savedTask
+  };
+}
+async function syncIssueManagerContentReferences(input) {
+  const existingPaths = new Set(input.existingRefs.map((ref) => ref.path));
+  const missingRefs = extractIssueManagerWorkspaceFileLinksFromContent(
+    input.content
+  ).filter((ref) => !existingPaths.has(ref.path)).map((ref) => ({
+    displayName: ref.name,
+    path: ref.path,
+    refType: ref.kind
+  }));
+  if (missingRefs.length === 0) {
+    return;
+  }
+  await input.backend.addContextRefs(
+    input.parentKind === "task" ? {
+      issueId: input.issueId,
+      parentKind: "task",
+      refs: missingRefs,
+      taskId: input.taskId ?? "",
+      workspaceId: input.workspaceId
+    } : {
+      issueId: input.issueId,
+      parentKind: "issue",
+      refs: missingRefs,
+      workspaceId: input.workspaceId
+    }
+  );
+}
+
+// src/services/internal/share/controllerShareCommands.ts
+function canIssueManagerCreateShareLink(shareAdapter) {
+  return typeof shareAdapter?.createIssueLink === "function";
+}
+async function executeIssueManagerShareSelection(input) {
+  const link = await input.shareAdapter.createIssueLink({
+    issueId: input.issueId,
+    taskId: input.taskId ?? void 0,
+    workspaceId: input.workspaceId
+  });
+  if (typeof navigator === "undefined" || !navigator.clipboard?.writeText) {
+    throw new Error("issue_manager.clipboard_unavailable");
+  }
+  await navigator.clipboard.writeText(link);
+}
+
+// src/services/internal/controllerActions.ts
+function createIssueManagerControllerActions(input) {
+  const {
+    copy,
+    feature,
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    nodeState,
+    referenceTarget,
+    refreshAll,
+    refreshDetails,
+    setNotification,
+    setIsRunningTask,
+    setIssueDraftInternal,
+    setIssueEditorModeState,
+    setReferenceTarget,
+    setTaskDraftInternal,
+    setTaskEditorModeState,
+    taskDetail,
+    taskDraft,
+    taskEditorMode,
+    updateNodeState,
+    workspaceId
+  } = input;
+  const notifyTip = (message, tone = "destructive") => {
+    setNotification({
+      title: message,
+      tone
+    });
+  };
+  const notifyError = (error, fallbackKey) => {
+    setNotification({
+      title: resolveIssueManagerErrorMessage(error, copy, fallbackKey),
+      tone: "destructive"
+    });
+  };
+  const applyOutcome = (outcome) => {
+    applyIssueManagerControllerOutcome({
+      notify: notifyTip,
+      outcome,
+      refreshAll,
+      refreshDetails,
+      setIssueDraftInternal,
+      setIssueEditorModeState,
+      setReferenceTarget: (target) => setReferenceTarget(target),
+      setTaskDraftInternal,
+      setTaskEditorModeState,
+      translate: (key) => copy.t(key),
+      updateNodeState
+    });
+  };
+  const submitReferences = async (refs, target = referenceTarget) => {
+    if (!target) {
+      applyOutcome({
+        referenceTarget: null
+      });
+      return;
+    }
+    if (target.mode === "insert") {
+      applyOutcome(
+        createIssueManagerInsertReferencesOutcome({
+          refs,
+          target
+        })
+      );
+      return;
+    }
+    const attached = await executeIssueManagerAttachReferences({
+      backend: feature.backend,
+      refs,
+      selectedIssueId: nodeState.selectedIssueId,
+      target,
+      workspaceId
+    });
+    applyOutcome(createIssueManagerAttachReferencesOutcome(attached));
+  };
+  return {
+    async attachReferences(parentKind) {
+      const fileAdapter = feature.fileAdapter;
+      const attachPlan = createIssueManagerAttachReferencesPlan({
+        hasFileAdapter: Boolean(fileAdapter),
+        parentKind,
+        requestReferencesDirectly: canIssueManagerRequestReferencesDirectly(fileAdapter),
+        selectedTaskId: nodeState.selectedTaskId
+      });
+      if (attachPlan.kind === "skip") {
+        return;
+      }
+      if (attachPlan.kind === "request_directly") {
+        if (!canIssueManagerRequestReferencesDirectly(fileAdapter)) {
+          return;
+        }
+        const refs = await executeIssueManagerRequestReferences({
+          fileAdapter,
+          workspaceId
+        });
+        await submitReferences(refs, attachPlan.target);
+        return;
+      }
+      applyOutcome(
+        createIssueManagerOpenReferencePickerOutcome(attachPlan.target)
+      );
+    },
+    createTaskDraft() {
+      setTaskEditorModeState("create");
+      setTaskDraftInternal({
+        content: nodeState.taskDraftContent ?? "",
+        priority: defaultTaskPriority,
+        title: nodeState.taskDraftTitle ?? ""
+      });
+      updateNodeState((current) => ({
+        ...current,
+        selectedTaskId: null
+      }));
+    },
+    async deleteIssue() {
+      const selectedIssueId = nodeState.selectedIssueId;
+      if (!selectedIssueId || !confirmIssueManagerMessage(copy.t("confirmations.deleteIssue"))) {
+        return;
+      }
+      try {
+        await feature.backend.deleteIssue({
+          issueId: selectedIssueId,
+          workspaceId
+        });
+        setIssueEditorModeState("read");
+        setTaskEditorModeState("read");
+        updateNodeState((current) => applyIssueManagerIssueDeleted(current));
+        refreshAll();
+      } catch (error) {
+        notifyError(error, "messages.issueDeleteFailed");
+      }
+    },
+    async deleteTask() {
+      const selectedIssueId = nodeState.selectedIssueId;
+      const selectedTaskId = nodeState.selectedTaskId;
+      if (!selectedIssueId || !selectedTaskId || !confirmIssueManagerMessage(copy.t("confirmations.deleteTask"))) {
+        return;
+      }
+      try {
+        await feature.backend.deleteTask({
+          issueId: selectedIssueId,
+          taskId: selectedTaskId,
+          workspaceId
+        });
+        setTaskEditorModeState("read");
+        updateNodeState((current) => applyIssueManagerTaskDeleted(current));
+        refreshAll();
+      } catch (error) {
+        notifyError(error, "messages.taskDeleteFailed");
+      }
+    },
+    async insertReferences(parentKind) {
+      const fileAdapter = feature.fileAdapter;
+      const insertPlan = createIssueManagerInsertReferencesPlan({
+        hasFileAdapter: Boolean(fileAdapter),
+        parentKind,
+        requestReferencesDirectly: canIssueManagerRequestReferencesDirectly(fileAdapter),
+        selectedTaskId: nodeState.selectedTaskId,
+        taskEditorMode
+      });
+      if (insertPlan.kind === "skip") {
+        return;
+      }
+      if (insertPlan.kind === "request_directly") {
+        if (!canIssueManagerRequestReferencesDirectly(fileAdapter)) {
+          return;
+        }
+        const refs = await executeIssueManagerRequestReferences({
+          fileAdapter,
+          workspaceId
+        });
+        await submitReferences(refs, insertPlan.target);
+        return;
+      }
+      applyOutcome(
+        createIssueManagerOpenReferencePickerOutcome(insertPlan.target)
+      );
+    },
+    async uploadReferences(parentKind, mode) {
+      const fileAdapter = feature.fileAdapter;
+      if (!canIssueManagerUploadReferences(fileAdapter)) {
+        return;
+      }
+      const refs = await executeIssueManagerUploadReferences({
+        fileAdapter,
+        mode,
+        workspaceId
+      });
+      if (refs.length === 0) {
+        return;
+      }
+      await submitReferences(
+        refs,
+        createIssueManagerInsertReferenceTarget(
+          parentKind,
+          nodeState.selectedTaskId
+        )
+      );
+    },
+    async openReference(reference) {
+      const fileAdapter = feature.fileAdapter;
+      if (!canIssueManagerOpenReferences(fileAdapter)) {
+        return;
+      }
+      await executeIssueManagerOpenReference({
+        fileAdapter,
+        reference
+      });
+    },
+    async removeContextRef(ref) {
+      try {
+        await executeIssueManagerRemoveContextRef({
+          backend: feature.backend,
+          ref,
+          workspaceId
+        });
+        refreshDetails();
+      } catch (error) {
+        notifyError(error, "messages.referenceRemoveFailed");
+      }
+    },
+    async runTask(providerOverride) {
+      const runPlan = createIssueManagerRunTaskPlan({
+        issueDetail: issueDetail.value,
+        providerOverride,
+        selectedAgentProvider: nodeState.selectedAgentProvider,
+        taskDetail: taskDetail.value
+      });
+      if (runPlan.kind !== "ready") {
+        return;
+      }
+      const currentIssueDetail = issueDetail.value;
+      const currentTaskDetail = taskDetail.value;
+      if (!currentIssueDetail || !currentTaskDetail) {
+        return;
+      }
+      if (runPlan.shouldUpdateSelectedAgentProvider) {
+        updateNodeState(
+          (current) => applyIssueManagerSelectedAgentProvider(current, runPlan.provider)
+        );
+      }
+      setIsRunningTask(true);
+      try {
+        const result = await executeIssueManagerRunTask({
+          copy,
+          feature,
+          issue: currentIssueDetail.issue,
+          onCreatedRun: refreshDetails,
+          provider: runPlan.provider,
+          task: currentTaskDetail.task,
+          workspaceId
+        });
+        const outcome = createIssueManagerRunTaskSuccessOutcome({
+          status: result.status
+        });
+        applyOutcome(outcome);
+      } catch (error) {
+        notifyTip(
+          resolveIssueManagerErrorMessage(error, copy, "messages.runFailed")
+        );
+      } finally {
+        setIsRunningTask(false);
+        refreshDetails();
+      }
+    },
+    async saveIssue() {
+      const savePlan = createIssueManagerSaveIssuePlan({
+        issueDraft
+      });
+      if (savePlan.kind === "blocked") {
+        notifyTip(copy.t(savePlan.notificationKey));
+        return;
+      }
+      try {
+        const { savedIssue } = await executeIssueManagerSaveIssue({
+          feature,
+          issueDetail: issueDetail.value,
+          issueDraft,
+          issueEditorMode,
+          selectedIssueId: nodeState.selectedIssueId,
+          workspaceId
+        });
+        const outcome = createIssueManagerSaveIssueSuccessOutcome(
+          savedIssue.issueId
+        );
+        applyOutcome(outcome);
+      } catch (error) {
+        notifyError(error, "messages.issueSaveFailed");
+      }
+    },
+    async saveTask() {
+      const savePlan = createIssueManagerSaveTaskPlan({
+        selectedIssueId: nodeState.selectedIssueId,
+        taskDraft
+      });
+      if (savePlan.kind === "skip") {
+        return;
+      }
+      if (savePlan.kind === "blocked") {
+        notifyTip(copy.t(savePlan.notificationKey));
+        return;
+      }
+      try {
+        const { savedTask } = await executeIssueManagerSaveTask({
+          feature,
+          selectedIssueId: savePlan.selectedIssueId,
+          selectedTaskId: nodeState.selectedTaskId,
+          taskDetail: taskDetail.value,
+          taskDraft,
+          taskEditorMode,
+          workspaceId
+        });
+        const outcome = createIssueManagerSaveTaskSuccessOutcome(
+          savedTask.taskId
+        );
+        applyOutcome(outcome);
+      } catch (error) {
+        notifyError(error, "messages.taskSaveFailed");
+      }
+    },
+    async shareSelection() {
+      const selectedIssueId = nodeState.selectedIssueId;
+      const shareAdapter = feature.shareAdapter;
+      if (!canIssueManagerCreateShareLink(shareAdapter) || !selectedIssueId) {
+        return;
+      }
+      try {
+        await executeIssueManagerShareSelection({
+          issueId: selectedIssueId,
+          shareAdapter,
+          taskId: nodeState.selectedTaskId,
+          workspaceId
+        });
+      } catch (error) {
+        notifyError(error, "messages.copyShareLinkFailed");
+      }
+    },
+    async submitReferenceSelection(refs) {
+      await submitReferences(refs);
+    }
+  };
+}
+
+// src/ui/react/internal/controller/createIssueManagerControllerActionsBridge.ts
+function createIssueManagerControllerActionsBridge(input) {
+  const {
+    controllerSession,
+    copy,
+    feature,
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    nodeState,
+    referenceTarget,
+    taskDetail,
+    taskDraft,
+    taskEditorMode,
+    workspaceId
+  } = input;
+  return createIssueManagerControllerActions({
+    copy,
+    feature,
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    nodeState,
+    referenceTarget,
+    refreshAll: () => controllerSession.refreshAll(),
+    refreshDetails: () => controllerSession.refreshDetails(),
+    setNotification: (update) => controllerSession.setNotification(
+      (current) => createIssueManagerControllerNotificationState(current, update)
+    ),
+    setIsRunningTask: (update) => controllerSession.setIsRunningTask(update),
+    setIssueDraftInternal: (update) => controllerSession.setIssueDraftInternal(update),
+    setIssueEditorModeState: (update) => controllerSession.setIssueEditorModeState(update),
+    setReferenceTarget: (update) => controllerSession.setReferenceTarget(update),
+    setTaskDraftInternal: (update) => controllerSession.setTaskDraftInternal(update),
+    setTaskEditorModeState: (update) => controllerSession.setTaskEditorModeState(update),
+    taskDetail,
+    taskDraft,
+    taskEditorMode,
+    updateNodeState: (updater) => controllerSession.updateNodeState(updater),
+    workspaceId
+  });
+}
+function createIssueManagerControllerNotificationState(current, input) {
+  return {
+    id: (current?.id ?? 0) + 1,
+    title: input.title,
+    tone: input.tone ?? "default"
+  };
+}
+
+// src/ui/react/internal/issue/createIssueManagerIssueBindings.ts
+function createIssueManagerIssueBindings(input) {
+  const { controllerSession, issueEditorMode, nodeState } = input;
+  return {
+    setIssueContent(content) {
+      controllerSession.setIssueDraftInternal((current) => ({
+        ...current,
+        content
+      }));
+      controllerSession.updateNodeState(
+        (current) => persistIssueManagerIssueDraftContent(current, issueEditorMode, content)
+      );
+    },
+    setIssueDraft(patch) {
+      controllerSession.setIssueDraftInternal((current) => ({
+        ...current,
+        ...patch
+      }));
+    },
+    setIssueEditorMode(mode) {
+      controllerSession.setIssueEditorModeState(mode);
+      if (mode === "create") {
+        controllerSession.setIssueDraftInternal(
+          createIssueManagerIssueDraftFromNodeState(nodeState)
+        );
+      }
+      controllerSession.updateNodeState(
+        (current) => applyIssueManagerIssueEditorModeToNodeState(current, mode)
+      );
+    },
+    setIssueSearchQuery(query) {
+      controllerSession.updateNodeState((current) => ({
+        ...current,
+        issueSearchQuery: query
+      }));
+    },
+    setIssueStatusFilter(value) {
+      controllerSession.updateNodeState((current) => ({
+        ...current,
+        issueStatusFilter: value
+      }));
+    },
+    setIssueTitle(title) {
+      controllerSession.setIssueDraftInternal((current) => ({
+        ...current,
+        title
+      }));
+      controllerSession.updateNodeState(
+        (current) => persistIssueManagerIssueDraftTitle(current, issueEditorMode, title)
+      );
+    }
+  };
+}
+
+// src/ui/react/internal/task/createIssueManagerTaskBindings.ts
+function createIssueManagerTaskBindings(input) {
+  const { controllerSession, nodeState, taskEditorMode } = input;
+  return {
+    selectTask(taskId) {
+      controllerSession.updateNodeState(
+        (current) => applyIssueManagerTaskSelection(current, taskId)
+      );
+      controllerSession.setTaskEditorModeState("read");
+    },
+    setTaskContent(content) {
+      controllerSession.setTaskDraftInternal((current) => ({
+        ...current,
+        content
+      }));
+      controllerSession.updateNodeState(
+        (current) => persistIssueManagerTaskDraftContent(current, taskEditorMode, content)
+      );
+    },
+    setTaskDraft(patch) {
+      controllerSession.setTaskDraftInternal((current) => ({
+        ...current,
+        ...patch
+      }));
+    },
+    setTaskEditorMode(mode) {
+      controllerSession.setTaskEditorModeState(mode);
+      if (mode === "create") {
+        controllerSession.setTaskDraftInternal(
+          createIssueManagerTaskDraftFromNodeState(nodeState)
+        );
+      }
+      controllerSession.updateNodeState(
+        (current) => applyIssueManagerTaskEditorModeToNodeState(current, mode)
+      );
+    },
+    setTaskListCollapsed(collapsed) {
+      controllerSession.updateNodeState((current) => ({
+        ...current,
+        taskListCollapsed: collapsed
+      }));
+    },
+    setTaskPriority(priority) {
+      controllerSession.setTaskDraftInternal((current) => ({
+        ...current,
+        priority
+      }));
+    },
+    setTaskTitle(title) {
+      controllerSession.setTaskDraftInternal((current) => ({
+        ...current,
+        title
+      }));
+      controllerSession.updateNodeState(
+        (current) => persistIssueManagerTaskDraftTitle(current, taskEditorMode, title)
+      );
+    }
+  };
+}
+
+// src/ui/react/internal/controller/createIssueManagerControllerBindings.ts
+function createIssueManagerControllerBindings(input) {
+  const {
+    controllerSession,
+    issueEditorMode,
+    nodeState,
+    onResolveRichTextAtProviders,
+    taskEditorMode,
+    workspaceId
+  } = input;
+  const issueBindings = createIssueManagerIssueBindings({
+    controllerSession,
+    issueEditorMode,
+    nodeState
+  });
+  const taskBindings = createIssueManagerTaskBindings({
+    controllerSession,
+    nodeState,
+    taskEditorMode
+  });
+  return {
+    ...issueBindings,
+    ...taskBindings,
+    dismissNotification() {
+      controllerSession.setNotification(null);
+    },
+    refreshAll() {
+      controllerSession.refreshAll();
+    },
+    resolveRichTextAtProviders(surface) {
+      return onResolveRichTextAtProviders?.({
+        surface,
+        workspaceId
+      }) ?? [];
+    },
+    selectIssue(issueId) {
+      controllerSession.updateNodeState(
+        (current) => applyIssueManagerIssueSelection(current, issueId)
+      );
+      controllerSession.setIssueEditorModeState("read");
+      controllerSession.setTaskEditorModeState("read");
+    },
+    setReferenceTarget(target) {
+      controllerSession.setReferenceTarget(target);
+    },
+    setSelectedAgentProvider(provider) {
+      controllerSession.updateNodeState((current) => ({
+        ...current,
+        selectedAgentProvider: provider
+      }));
+    }
+  };
+}
+
+// src/ui/react/internal/controller/useIssueManagerControllerRuntime.ts
+import { useDeferredValue, useEffect as useEffect2, useMemo } from "react";
+import { useSnapshot } from "valtio";
+
+// src/ui/react/internal/shell/IssueManagerNoticeState.ts
+var issueManagerNoticeDurationMs = 3200;
+function resolveIssueManagerFloatingNoticeViewState(input) {
+  if (!input.notification) {
+    return null;
+  }
+  return {
+    durationMs: issueManagerNoticeDurationMs,
+    id: input.notification.id,
+    isLoading: false,
+    title: input.notification.title,
+    tone: input.notification.tone
+  };
+}
+
+// src/ui/react/internal/controller/useIssueManagerControllerRuntime.ts
+function useIssueManagerControllerRuntime(input) {
+  const { feature, onStateChange, service, state, workspaceId } = input;
+  const controllerService = useMemo(
+    () => service ?? createIssueManagerControllerService(),
+    [service]
+  );
+  const controllerSession = useMemo(
+    () => controllerService.createSession({
+      feature,
+      state,
+      workspaceId
+    }),
+    [controllerService, feature, workspaceId]
+  );
+  const snapshot = useSnapshot(
+    controllerSession.store
+  );
+  const deferredIssueSearch = useDeferredValue(
+    snapshot.nodeState.issueSearchQuery
+  );
+  const floatingNotice = resolveIssueManagerFloatingNoticeViewState({
+    notification: snapshot.notification
+  });
+  useEffect2(() => {
+    controllerSession.retain();
+    return () => {
+      controllerSession.release();
+    };
+  }, [controllerSession]);
+  useEffect2(() => {
+    controllerSession.syncInput({
+      deferredIssueSearch,
+      onStateChange,
+      taskListCollapsed: state?.taskListCollapsed === true
+    });
+  }, [
+    controllerSession,
+    deferredIssueSearch,
+    onStateChange,
+    state?.taskListCollapsed
+  ]);
+  return {
+    controllerSession,
+    deferredIssueSearch,
+    floatingNotice,
+    snapshot
+  };
+}
+
+// src/ui/react/internal/controller/useIssueManagerController.ts
+function useIssueManagerController({
+  feature,
+  onStateChange,
+  resolveRichTextAtProviders,
+  service,
+  state,
+  workspaceId
+}) {
+  const copy = feature.i18n;
+  const { controllerSession, floatingNotice, snapshot } = useIssueManagerControllerRuntime({
+    feature,
+    onStateChange,
+    service,
+    state,
+    workspaceId
+  });
+  const {
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    issues,
+    isRunningTask,
+    nodeState,
+    notification,
+    referenceTarget,
+    taskDetail,
+    taskDraft,
+    taskEditorMode
+  } = snapshot;
+  const {
+    canInviteCollaborators,
+    canReferenceWorkspaceFiles,
+    canUploadWorkspaceFiles
+  } = useMemo2(
+    () => resolveIssueManagerControllerCapabilities(feature),
+    [feature]
+  );
+  const actions = createIssueManagerControllerActionsBridge({
+    controllerSession,
+    copy,
+    feature,
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    nodeState,
+    referenceTarget,
+    taskDetail,
+    taskDraft,
+    taskEditorMode,
+    workspaceId
+  });
+  const bindings = createIssueManagerControllerBindings({
+    controllerSession,
+    issueEditorMode,
+    nodeState,
+    onResolveRichTextAtProviders: resolveRichTextAtProviders,
+    taskEditorMode,
+    workspaceId
+  });
+  return {
+    ...actions,
+    ...bindings,
+    canInviteCollaborators,
+    canReferenceWorkspaceFiles,
+    canUploadWorkspaceFiles,
+    copy,
+    issueDetail,
+    issueDraft,
+    issueEditorMode,
+    floatingNotice,
+    issues,
+    isRunningTask,
+    nodeState,
+    notification,
+    providerOptions: issueManagerProviderOptions,
+    referenceTarget,
+    taskDetail,
+    taskDraft,
+    taskEditorMode,
+    workspaceId
+  };
+}
+
+// src/ui/react/internal/shell/useIssueManagerNodeView.ts
+function useIssueManagerNodeView({
+  feature,
+  nodeId,
+  onStateChange,
+  resolveRichTextAtProviders,
+  service,
+  state,
+  workspaceId
+}) {
+  const controller = useIssueManagerController({
+    feature,
+    onStateChange,
+    resolveRichTextAtProviders,
+    service,
+    state,
+    workspaceId
+  });
+  useIssueManagerTaskListCollapsedSync({
+    nodeId,
+    onCollapsedChange: (collapsed) => {
+      controller.setTaskListCollapsed(collapsed);
+    }
+  });
+  const selectedIssue = resolveIssueManagerSelectedIssue({
+    issueDetail: controller.issueDetail.value?.issue ?? null,
+    issues: controller.issues.value,
+    selectedIssueId: controller.nodeState.selectedIssueId
+  });
+  const selectedTask = resolveIssueManagerSelectedTask({
+    selectedTaskId: controller.nodeState.selectedTaskId,
+    taskDetail: controller.taskDetail.value?.task ?? null,
+    tasks: controller.issueDetail.value?.tasks ?? []
+  });
+  return {
+    controller,
+    referencePicker: {
+      onClose: () => {
+        controller.setReferenceTarget(null);
+      },
+      onConfirm: (refs) => {
+        void controller.submitReferenceSelection(refs);
+      },
+      open: controller.referenceTarget !== null
+    },
+    selectedIssue,
+    selectedTask,
+    shell: {
+      onCloseTaskDrawer: () => {
+        controller.setTaskEditorMode("read");
+        controller.selectTask(null);
+      },
+      onDismissIssueCreate: () => {
+        controller.setIssueEditorMode("read");
+      }
+    }
+  };
+}
+
+// src/ui/react/internal/reference/useIssueManagerReferencePickerView.ts
+import { useEffect as useEffect3, useEffectEvent as useEffectEvent2, useMemo as useMemo3, useState as useState2 } from "react";
+var defaultDirectoryPath = "/";
+function useIssueManagerReferencePickerView({
+  fileAdapter,
+  onClose,
+  onConfirm,
+  open,
+  workspaceId
+}) {
+  const [searchQuery, setSearchQuery] = useState2("");
+  const [browseRootPath, setBrowseRootPath] = useState2(null);
+  const [searchEntries, setSearchEntries] = useState2([]);
+  const [directoryStateByPath, setDirectoryStateByPath] = useState2({});
+  const [expandedFolderPaths, setExpandedFolderPaths] = useState2({});
+  const [focusedPath, setFocusedPath] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [selectedRefs, setSelectedRefs] = useState2(
+    []
+  );
+  const supportsSearch = hasFileAdapterMethod2(fileAdapter, "searchReferences");
+  const supportsTreeSnapshot = hasFileAdapterMethod2(
+    fileAdapter,
+    "loadReferenceTree"
+  );
+  const mode = searchQuery.trim().length > 0 && supportsSearch ? "search" : "browse";
+  const browseDirectoryLoaded = browseRootPath !== null && directoryStateByPath[normalizeDirectoryPath(browseRootPath)]?.loaded === true;
+  const finalizeRequestedReferences = useEffectEvent2(
+    (refs) => {
+      onConfirm(uniqueIssueManagerFileReferences(refs));
+      onClose();
+    }
+  );
+  const readDirectoryListing = async (path) => {
+    if (!fileAdapter?.listDirectory) {
+      return null;
+    }
+    const listing = await fileAdapter.listDirectory({
+      path: path ?? void 0,
+      workspaceId
+    });
+    return {
+      displayPath: listing.directoryPath || listing.rootPath || path || defaultDirectoryPath,
+      entries: uniqueIssueManagerFileReferences(listing.entries),
+      normalizedPath: normalizeDirectoryPath(
+        listing.directoryPath || listing.rootPath || path || defaultDirectoryPath
+      )
+    };
+  };
+  useEffect3(() => {
+    if (!open) {
+      return;
+    }
+    setSearchQuery("");
+    setBrowseRootPath(null);
+    setSearchEntries([]);
+    setDirectoryStateByPath({});
+    setExpandedFolderPaths({});
+    setFocusedPath(null);
+    setSelectedRefs([]);
+  }, [open]);
+  useEffect3(() => {
+    if (!open || !fileAdapter) {
+      return;
+    }
+    let canceled = false;
+    const load = async () => {
+      setIsLoading(true);
+      try {
+        if (mode === "search" && fileAdapter.searchReferences) {
+          const refs = await fileAdapter.searchReferences({
+            query: searchQuery.trim(),
+            workspaceId
+          });
+          if (!canceled) {
+            setSearchEntries(uniqueIssueManagerFileReferences(refs));
+          }
+          return;
+        }
+        if (mode === "browse" && (fileAdapter.listDirectory || fileAdapter.loadReferenceTree)) {
+          if (browseDirectoryLoaded && browseRootPath) {
+            return;
+          }
+          if (supportsTreeSnapshot && fileAdapter.loadReferenceTree) {
+            const snapshot = await fileAdapter.loadReferenceTree({
+              path: browseRootPath ?? void 0,
+              prefetchBudgetMs: 500,
+              prefetchDepth: 4,
+              workspaceId
+            });
+            if (!canceled) {
+              setBrowseRootPath(
+                normalizeDirectoryPath(snapshot.directory.directoryPath)
+              );
+              setDirectoryStateByPath(
+                createReferenceDirectoryStateFromSnapshot(snapshot)
+              );
+            }
+            return;
+          }
+          const listing = await readDirectoryListing(browseRootPath);
+          if (!listing) {
+            return;
+          }
+          if (!canceled) {
+            setBrowseRootPath(listing.normalizedPath);
+            setDirectoryStateByPath((current) => ({
+              ...current,
+              [listing.normalizedPath]: {
+                displayPath: listing.displayPath,
+                entries: listing.entries,
+                loaded: true,
+                loading: false
+              }
+            }));
+          }
+          return;
+        }
+        if (fileAdapter.requestReferences) {
+          const refs = await fileAdapter.requestReferences({ workspaceId });
+          if (!canceled) {
+            finalizeRequestedReferences(refs);
+          }
+          return;
+        }
+        if (!canceled) {
+          setSearchEntries([]);
+        }
+      } finally {
+        if (!canceled) {
+          setIsLoading(false);
+        }
+      }
+    };
+    void load();
+    return () => {
+      canceled = true;
+    };
+  }, [
+    browseDirectoryLoaded,
+    browseRootPath,
+    fileAdapter,
+    finalizeRequestedReferences,
+    mode,
+    open,
+    searchQuery,
+    supportsTreeSnapshot,
+    workspaceId
+  ]);
+  const browseRootEntries = useMemo3(
+    () => browseRootPath ? directoryStateByPath[normalizeDirectoryPath(browseRootPath)]?.entries ?? [] : [],
+    [browseRootPath, directoryStateByPath]
+  );
+  const visibleEntries = useMemo3(
+    () => mode === "search" ? searchEntries : collectVisibleTreeEntries(
+      browseRootEntries,
+      directoryStateByPath,
+      expandedFolderPaths
+    ),
+    [
+      browseRootEntries,
+      directoryStateByPath,
+      expandedFolderPaths,
+      mode,
+      searchEntries
+    ]
+  );
+  useEffect3(() => {
+    if (!open) {
+      return;
+    }
+    setFocusedPath((current) => {
+      if (current && visibleEntries.some((entry) => entry.path === current)) {
+        return current;
+      }
+      return visibleEntries[0]?.path ?? null;
+    });
+  }, [open, visibleEntries]);
+  const focusedEntry = visibleEntries.find((entry) => entry.path === focusedPath) ?? selectedRefs.find((entry) => entry.path === focusedPath) ?? null;
+  const toggleRef = (ref) => {
+    setSelectedRefs((current) => {
+      const existing = current.some((item) => item.path === ref.path);
+      return existing ? current.filter((item) => item.path !== ref.path) : uniqueIssueManagerFileReferences([...current, ref]);
+    });
+  };
+  const loadFolderChildren = async (folder) => {
+    const folderKey = normalizeDirectoryPath(folder.path);
+    if (directoryStateByPath[folderKey]?.loaded) {
+      return;
+    }
+    setDirectoryStateByPath((current) => ({
+      ...current,
+      [folderKey]: {
+        displayPath: folder.path,
+        entries: current[folderKey]?.entries ?? [],
+        loaded: current[folderKey]?.loaded ?? false,
+        loading: true
+      }
+    }));
+    try {
+      const listing = await readDirectoryListing(folderKey);
+      if (!listing) {
+        return;
+      }
+      setDirectoryStateByPath((current) => ({
+        ...current,
+        [folderKey]: {
+          displayPath: listing.displayPath,
+          entries: listing.entries,
+          loaded: true,
+          loading: false
+        }
+      }));
+    } catch {
+      setDirectoryStateByPath((current) => ({
+        ...current,
+        [folderKey]: {
+          displayPath: current[folderKey]?.displayPath ?? folder.path,
+          entries: current[folderKey]?.entries ?? [],
+          loaded: current[folderKey]?.loaded ?? false,
+          loading: false
+        }
+      }));
+    }
+  };
+  const toggleFolder = (entry) => {
+    const folderKey = normalizeDirectoryPath(entry.path);
+    const childState = directoryStateByPath[folderKey];
+    const nextExpanded = !(expandedFolderPaths[folderKey] ?? false);
+    setExpandedFolderPaths((current) => ({
+      ...current,
+      [folderKey]: nextExpanded
+    }));
+    if (nextExpanded && !childState?.loaded && !childState?.loading) {
+      void loadFolderChildren(entry);
+    }
+  };
+  return {
+    browseRootEntries,
+    directoryStateByPath,
+    expandedFolderPaths,
+    focusedEntry,
+    focusedPath,
+    isLoading,
+    mode,
+    searchQuery,
+    selectedRefs,
+    visibleEntries,
+    setFocusedPath,
+    setSearchQuery,
+    toggleFolder,
+    toggleRef
+  };
+}
+function hasFileAdapterMethod2(fileAdapter, methodName) {
+  return typeof Reflect.get(fileAdapter ?? {}, methodName) === "function";
+}
+
+// src/ui/IssueManagerNode.tsx
+import { Button as Button14, PanelIcon, cn as cn10 } from "@nextop-os/ui-system";
+
+// src/ui/internal/reference/IssueManagerReferencePicker.tsx
+import { useMemo as useMemo4 } from "react";
+import { createPortal } from "react-dom";
+import {
+  Button as Button3,
+  Card,
+  CardContent,
+  CardDescription,
+  CardHeader,
+  CardTitle,
+  CloseIcon
+} from "@nextop-os/ui-system";
+
+// src/ui/internal/reference/IssueManagerReferencePickerSections.tsx
+import { Badge, Button as Button2, DirectoryIcon as DirectoryIcon2, FileIcon as FileIcon2 } from "@nextop-os/ui-system";
+
+// src/ui/internal/reference/IssueManagerReferencePickerTree.tsx
+import {
+  ArrowRightIcon,
+  Button,
+  CheckIcon,
+  DirectoryIcon,
+  FileIcon,
+  Input,
+  LoadingIcon,
+  ScrollArea,
+  SearchIcon,
+  cn
+} from "@nextop-os/ui-system";
+import { jsx, jsxs } from "react/jsx-runtime";
+var issueManagerReferenceTreeIndent = 20;
+function IssueManagerReferencePickerBrowserPane({
+  browseRootEntries,
+  copy,
+  directoryStateByPath,
+  expandedFolderPaths,
+  focusedPath,
+  isLoading,
+  mode,
+  searchQuery,
+  selectedRefs,
+  setSearchQuery,
+  visibleEntries,
+  onFocusPath,
+  onToggleFolder,
+  onToggleRef
+}) {
+  return /* @__PURE__ */ jsxs("section", { className: "flex min-h-0 flex-col border-b border-border/70 lg:border-r lg:border-b-0", children: [
+    /* @__PURE__ */ jsx("div", { className: "space-y-3 border-b border-border/70 px-4 py-4 sm:px-5", children: /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+      /* @__PURE__ */ jsx(SearchIcon, { className: "pointer-events-none absolute top-1/2 left-3 size-4 -translate-y-1/2 text-muted-foreground" }),
+      /* @__PURE__ */ jsx(
+        Input,
+        {
+          className: "pl-9",
+          placeholder: copy.t("referencePicker.searchPlaceholder"),
+          value: searchQuery,
+          onChange: (event) => setSearchQuery(event.target.value)
+        }
+      )
+    ] }) }),
+    /* @__PURE__ */ jsx(ScrollArea, { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-2 p-3", children: isLoading ? /* @__PURE__ */ jsx(IssueManagerReferencePickerFeedback, { children: /* @__PURE__ */ jsx(LoadingIcon, { className: "size-4 animate-spin" }) }) : visibleEntries.length === 0 ? /* @__PURE__ */ jsx(IssueManagerReferencePickerFeedback, { children: mode === "search" ? copy.t("referencePicker.emptySearch") : copy.t("referencePicker.emptyDirectory") }) : mode === "browse" ? /* @__PURE__ */ jsx("div", { className: "space-y-0.5", children: browseRootEntries.map((entry) => /* @__PURE__ */ jsx(
+      IssueManagerReferencePickerTreeEntry,
+      {
+        childDepth: 1,
+        copy,
+        directoryStateByPath,
+        entry,
+        expandedFolderPaths,
+        focusedPath,
+        selectedRefs,
+        onFocusPath,
+        onToggleFolder,
+        onToggleRef
+      },
+      entry.path
+    )) }) : visibleEntries.map((entry) => /* @__PURE__ */ jsx(
+      IssueManagerReferencePickerSearchEntry,
+      {
+        entry,
+        focused: focusedPath === entry.path,
+        selected: selectedRefs.some((item) => item.path === entry.path),
+        onFocusPath,
+        onToggleRef
+      },
+      entry.path
+    )) }) })
+  ] });
+}
+function IssueManagerReferencePickerTreeEntry({
+  childDepth,
+  copy,
+  directoryStateByPath,
+  entry,
+  expandedFolderPaths,
+  focusedPath,
+  selectedRefs,
+  onFocusPath,
+  onToggleFolder,
+  onToggleRef
+}) {
+  const selected = selectedRefs.some((item) => item.path === entry.path);
+  const focused = focusedPath === entry.path;
+  const isFolder = entry.kind === "folder";
+  const folderKey = normalizeDirectoryPath(entry.path);
+  const expanded = expandedFolderPaths[folderKey] ?? false;
+  const childState = directoryStateByPath[folderKey];
+  const childEntries = childState?.entries ?? [];
+  return /* @__PURE__ */ jsxs("div", { children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "grid grid-cols-[auto_minmax(0,1fr)_auto] items-center gap-2 rounded-lg px-2 py-1.5 transition-colors",
+          focused || selected ? "bg-transparency-block" : "hover:bg-transparency-block/60"
+        ),
+        style: {
+          paddingLeft: `${(childDepth - 1) * issueManagerReferenceTreeIndent + 8}px`
+        },
+        children: [
+          isFolder ? /* @__PURE__ */ jsx(
+            "button",
+            {
+              "aria-label": resolveIssueManagerReferenceLabel(entry),
+              className: "grid size-5 shrink-0 place-items-center rounded-sm text-muted-foreground hover:bg-background/80",
+              type: "button",
+              onClick: () => onToggleFolder(entry),
+              children: /* @__PURE__ */ jsx(
+                ArrowRightIcon,
+                {
+                  className: cn(
+                    "size-3.5 transition-transform",
+                    expanded && "rotate-90"
+                  )
+                }
+              )
+            }
+          ) : /* @__PURE__ */ jsx("span", { className: "block size-5 shrink-0" }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              className: "flex min-w-0 items-center gap-2 text-left",
+              type: "button",
+              onClick: () => {
+                onFocusPath(entry.path);
+                if (entry.kind === "folder") {
+                  onToggleFolder(entry);
+                }
+              },
+              children: [
+                isFolder ? /* @__PURE__ */ jsx(DirectoryIcon, { className: "size-4 shrink-0 text-muted-foreground" }) : /* @__PURE__ */ jsx(FileIcon, { className: "size-4 shrink-0 text-muted-foreground" }),
+                /* @__PURE__ */ jsx("span", { className: "truncate text-sm text-foreground", children: resolveIssueManagerReferenceLabel(entry) })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Button,
+            {
+              size: "xs",
+              type: "button",
+              variant: selected ? "secondary" : "outline",
+              onClick: () => {
+                onFocusPath(entry.path);
+                onToggleRef(entry);
+              },
+              children: selected ? /* @__PURE__ */ jsx(CheckIcon, { size: 14 }) : "+"
+            }
+          )
+        ]
+      }
+    ),
+    isFolder && expanded ? childState?.loading ? /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: "flex items-center gap-2 px-2 py-2 text-xs text-muted-foreground",
+        style: {
+          paddingLeft: `${childDepth * issueManagerReferenceTreeIndent + 12}px`
+        },
+        children: [
+          /* @__PURE__ */ jsx(LoadingIcon, { className: "size-3.5 animate-spin" }),
+          /* @__PURE__ */ jsx("span", { children: copy.t("referencePicker.loading") })
+        ]
+      }
+    ) : childEntries.length > 0 ? childEntries.map((childEntry) => /* @__PURE__ */ jsx(
+      IssueManagerReferencePickerTreeEntry,
+      {
+        childDepth: childDepth + 1,
+        copy,
+        directoryStateByPath,
+        entry: childEntry,
+        expandedFolderPaths,
+        focusedPath,
+        selectedRefs,
+        onFocusPath,
+        onToggleFolder,
+        onToggleRef
+      },
+      childEntry.path
+    )) : childState?.loaded ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "px-2 py-2 text-xs text-muted-foreground",
+        style: {
+          paddingLeft: `${childDepth * issueManagerReferenceTreeIndent + 12}px`
+        },
+        children: copy.t("referencePicker.emptyDirectory")
+      }
+    ) : null : null
+  ] });
+}
+function IssueManagerReferencePickerSearchEntry({
+  entry,
+  focused,
+  selected,
+  onFocusPath,
+  onToggleRef
+}) {
+  const isFolder = entry.kind === "folder";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "grid grid-cols-[minmax(0,1fr)_auto] items-center gap-3 rounded-xl border px-3 py-2.5 transition-colors",
+        focused || selected ? "border-border bg-transparency-block" : "border-transparent bg-transparent hover:border-border/70 hover:bg-transparency-block/60"
+      ),
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            className: "flex min-w-0 items-center gap-3 text-left",
+            type: "button",
+            onClick: () => onFocusPath(entry.path),
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "grid size-9 shrink-0 place-items-center rounded-lg bg-background/90 text-muted-foreground", children: isFolder ? /* @__PURE__ */ jsx(DirectoryIcon, { className: "size-4" }) : /* @__PURE__ */ jsx(FileIcon, { className: "size-4" }) }),
+              /* @__PURE__ */ jsxs("span", { className: "min-w-0", children: [
+                /* @__PURE__ */ jsx("span", { className: "block truncate text-sm font-medium text-foreground", children: resolveIssueManagerReferenceLabel(entry) }),
+                /* @__PURE__ */ jsx("span", { className: "block truncate text-xs text-muted-foreground", children: entry.path })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            size: "xs",
+            type: "button",
+            variant: selected ? "secondary" : "outline",
+            onClick: () => {
+              onFocusPath(entry.path);
+              onToggleRef(entry);
+            },
+            children: selected ? /* @__PURE__ */ jsx(CheckIcon, { size: 14 }) : "+"
+          }
+        )
+      ]
+    }
+  );
+}
+function IssueManagerReferencePickerFeedback({
+  children
+}) {
+  return /* @__PURE__ */ jsx("div", { className: "grid min-h-[10rem] place-items-center px-4 text-center text-sm text-muted-foreground", children });
+}
+function resolveIssueManagerReferenceLabel(ref) {
+  return ref.displayName || ref.path.split("/").filter(Boolean).at(-1) || ref.path;
+}
+
+// src/ui/internal/reference/IssueManagerReferencePickerSections.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function IssueManagerReferencePickerPreviewPane({
+  copy,
+  focusedEntry,
+  mode
+}) {
+  return /* @__PURE__ */ jsx2("aside", { className: "flex shrink-0 flex-col border-t border-border/70 bg-panel/40 lg:min-h-0 lg:flex-1 lg:border-t-0", children: /* @__PURE__ */ jsx2("div", { className: "flex min-h-0 flex-1 flex-col px-4 py-4 sm:px-5 lg:py-5", children: focusedEntry ? /* @__PURE__ */ jsxs2("div", { className: "flex min-h-0 flex-col gap-4 lg:flex-1 lg:gap-5", children: [
+    /* @__PURE__ */ jsx2("div", { className: "flex h-32 min-h-32 items-center justify-center rounded-2xl border border-border/70 bg-background/72 p-5 sm:h-40 sm:min-h-40 lg:h-56 lg:min-h-56 lg:p-6", children: /* @__PURE__ */ jsxs2("div", { className: "space-y-4 text-center", children: [
+      /* @__PURE__ */ jsx2("span", { className: "mx-auto grid size-14 place-items-center rounded-2xl bg-transparency-block text-muted-foreground", children: focusedEntry.kind === "folder" ? /* @__PURE__ */ jsx2(DirectoryIcon2, { className: "size-7" }) : /* @__PURE__ */ jsx2(FileIcon2, { className: "size-7" }) }),
+      /* @__PURE__ */ jsx2("p", { className: "max-w-[24ch] text-sm leading-5 text-muted-foreground [overflow-wrap:anywhere]", children: focusedEntry.kind === "folder" ? focusedEntry.path : resolveIssueManagerReferenceLabel(focusedEntry) })
+    ] }) }),
+    /* @__PURE__ */ jsx2("div", { className: "space-y-2 lg:space-y-3", children: /* @__PURE__ */ jsxs2("div", { className: "space-y-1.5", children: [
+      /* @__PURE__ */ jsx2("p", { className: "truncate text-[15px] font-semibold text-foreground", children: resolveIssueManagerReferenceLabel(focusedEntry) }),
+      /* @__PURE__ */ jsx2("p", { className: "line-clamp-3 text-sm text-muted-foreground [overflow-wrap:anywhere]", children: focusedEntry.path })
+    ] }) })
+  ] }) : /* @__PURE__ */ jsx2(IssueManagerReferencePickerFeedback2, { children: mode === "search" ? copy.t("referencePicker.emptySearch") : copy.t("referencePicker.emptyDirectory") }) }) });
+}
+function IssueManagerReferencePickerFooter({
+  copy,
+  onClose,
+  onConfirm,
+  selectedRefs
+}) {
+  return /* @__PURE__ */ jsxs2("div", { className: "flex flex-col gap-3 border-t border-border/70 px-4 py-4 sm:px-6 lg:flex-row lg:items-center lg:justify-between", children: [
+    /* @__PURE__ */ jsxs2("div", { className: "flex min-w-0 flex-wrap items-center gap-2 lg:flex-1", children: [
+      /* @__PURE__ */ jsx2("span", { className: "text-sm text-muted-foreground", children: copy.t("referencePicker.selectedCount", {
+        count: selectedRefs.length
+      }) }),
+      selectedRefs.slice(0, 2).map((ref) => /* @__PURE__ */ jsx2(
+        Badge,
+        {
+          className: "max-w-[14rem] border-border/70 bg-background/80 text-foreground",
+          children: /* @__PURE__ */ jsx2("span", { className: "truncate", children: resolveIssueManagerReferenceLabel(ref) })
+        },
+        ref.path
+      )),
+      selectedRefs.length > 2 ? /* @__PURE__ */ jsxs2(Badge, { className: "border-border/70 bg-background/80 text-muted-foreground", children: [
+        "+",
+        selectedRefs.length - 2
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "flex w-full items-center justify-end gap-2 lg:w-auto lg:shrink-0", children: [
+      /* @__PURE__ */ jsx2(Button2, { type: "button", variant: "outline", onClick: onClose, children: copy.t("actions.cancel") }),
+      /* @__PURE__ */ jsx2(
+        Button2,
+        {
+          disabled: selectedRefs.length === 0,
+          type: "button",
+          onClick: onConfirm,
+          children: copy.t("referencePicker.confirm")
+        }
+      )
+    ] })
+  ] });
+}
+function IssueManagerReferencePickerFeedback2({
+  children
+}) {
+  return /* @__PURE__ */ jsx2("div", { className: "grid min-h-[10rem] place-items-center px-4 text-center text-sm text-muted-foreground", children });
+}
+
+// src/ui/internal/reference/IssueManagerReferencePicker.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function IssueManagerReferencePicker({
+  copy,
+  fileAdapter,
+  onClose,
+  onConfirm,
+  open,
+  workspaceId
+}) {
+  const {
+    browseRootEntries,
+    directoryStateByPath,
+    expandedFolderPaths,
+    focusedEntry,
+    focusedPath,
+    isLoading,
+    mode,
+    searchQuery,
+    selectedRefs,
+    visibleEntries,
+    setFocusedPath,
+    setSearchQuery,
+    toggleFolder,
+    toggleRef
+  } = useIssueManagerReferencePickerView({
+    fileAdapter,
+    onClose,
+    onConfirm,
+    open,
+    workspaceId
+  });
+  const selectedCountLabel = useMemo4(
+    () => copy.t("referencePicker.selectedCount", { count: selectedRefs.length }),
+    [copy, selectedRefs.length]
+  );
+  if (!open) {
+    return null;
+  }
+  const dialog = /* @__PURE__ */ jsx3(
+    "div",
+    {
+      className: "fixed inset-0 grid place-items-center bg-black/24 px-3 py-4 backdrop-blur-md sm:px-6 sm:py-8",
+      style: { zIndex: "var(--z-panel)" },
+      onClick: onClose,
+      children: /* @__PURE__ */ jsxs3(
+        Card,
+        {
+          "aria-modal": "true",
+          className: "flex h-[min(88vh,44rem)] w-full max-w-5xl flex-col gap-0 overflow-hidden border-border/70 bg-popover/98 py-0 shadow-[var(--workbench-window-elevation)] sm:h-[min(82vh,44rem)]",
+          role: "dialog",
+          onClick: (event) => event.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsx3(CardHeader, { className: "border-b border-border/70 px-4 py-4 sm:px-6 sm:py-5", children: /* @__PURE__ */ jsxs3("div", { className: "flex items-start justify-between gap-4", children: [
+              /* @__PURE__ */ jsxs3("div", { className: "min-w-0 space-y-1", children: [
+                /* @__PURE__ */ jsx3(CardTitle, { children: copy.t("referencePicker.title") }),
+                /* @__PURE__ */ jsx3(CardDescription, { children: selectedCountLabel })
+              ] }),
+              /* @__PURE__ */ jsx3(
+                Button3,
+                {
+                  "aria-label": copy.t("actions.cancel"),
+                  size: "icon-sm",
+                  type: "button",
+                  variant: "ghost",
+                  onClick: onClose,
+                  children: /* @__PURE__ */ jsx3(CloseIcon, { size: 16 })
+                }
+              )
+            ] }) }),
+            /* @__PURE__ */ jsxs3(CardContent, { className: "grid min-h-0 flex-1 grid-rows-[minmax(0,1fr)_auto] gap-0 overflow-hidden p-0 lg:grid-cols-[minmax(0,1.15fr)_minmax(20rem,0.85fr)] lg:grid-rows-1", children: [
+              /* @__PURE__ */ jsx3(
+                IssueManagerReferencePickerBrowserPane,
+                {
+                  browseRootEntries,
+                  copy,
+                  directoryStateByPath,
+                  expandedFolderPaths,
+                  focusedPath,
+                  isLoading,
+                  mode,
+                  searchQuery,
+                  selectedRefs,
+                  setSearchQuery,
+                  visibleEntries,
+                  onFocusPath: setFocusedPath,
+                  onToggleFolder: toggleFolder,
+                  onToggleRef: toggleRef
+                }
+              ),
+              /* @__PURE__ */ jsx3(
+                IssueManagerReferencePickerPreviewPane,
+                {
+                  copy,
+                  focusedEntry,
+                  mode
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsx3(
+              IssueManagerReferencePickerFooter,
+              {
+                copy,
+                onClose,
+                onConfirm: () => onConfirm(selectedRefs),
+                selectedRefs
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+  if (typeof document === "undefined") {
+    return dialog;
+  }
+  return createPortal(dialog, document.body);
+}
+
+// src/ui/internal/shell/IssueManagerShell.tsx
+import { Button as Button13, cn as cn9 } from "@nextop-os/ui-system";
+
+// src/ui/internal/shell/IssueManagerPanels.tsx
+import { Badge as Badge3, Button as Button7, Input as Input2 } from "@nextop-os/ui-system";
+
+// src/ui/internal/issue/IssueManagerIssueSections.tsx
+import {
+  Badge as Badge2,
+  Button as Button5,
+  FileCreateIcon as FileCreateIcon2,
+  ScrollArea as ScrollArea2,
+  cn as cn2
+} from "@nextop-os/ui-system";
+
+// src/ui/internal/panel/IssueManagerPanelText.ts
+function summarizeIssueManagerContent(content, fallback) {
+  const plainText = extractIssueManagerPlainTextFromContent(
+    content ?? ""
+  ).trim();
+  if (!plainText) {
+    return fallback;
+  }
+  if (plainText.length <= 120) {
+    return plainText;
+  }
+  return `${plainText.slice(0, 117)}...`;
+}
+function resolveTaskCreatorLabel(task) {
+  return resolveIssueManagerCreatorLabel(task);
+}
+function resolveIssueManagerCreatorLabel(entity) {
+  return entity.creatorDisplayName?.trim() || entity.creatorUserId;
+}
+
+// src/ui/internal/panel/IssueManagerPanelSurface.tsx
+import { Button as Button4, FileCreateIcon } from "@nextop-os/ui-system";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var workspaceDockTaskImage = new URL(
+  "../../../assets/workspace-dock-task.png",
+  import.meta.url
+).href;
+function IssueManagerEmptyIllustration() {
+  return /* @__PURE__ */ jsx4(
+    "img",
+    {
+      alt: "",
+      "aria-hidden": "true",
+      className: "h-[84px] w-[84px] object-contain",
+      decoding: "async",
+      draggable: false,
+      src: workspaceDockTaskImage
+    }
+  );
+}
+function IssueManagerPaneLoadingState() {
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "mx-auto flex w-full max-w-4xl flex-col gap-6",
+      children: [
+        /* @__PURE__ */ jsx4("div", { className: "h-6 w-28 rounded-full bg-muted" }),
+        /* @__PURE__ */ jsx4("div", { className: "h-12 w-2/3 rounded-full bg-muted" }),
+        /* @__PURE__ */ jsxs4("div", { className: "rounded-[28px] border border-border/70 bg-transparent px-5 py-5", children: [
+          /* @__PURE__ */ jsx4("div", { className: "h-4 w-24 rounded-full bg-muted" }),
+          /* @__PURE__ */ jsx4("div", { className: "mt-5 h-4 w-full rounded-full bg-muted" }),
+          /* @__PURE__ */ jsx4("div", { className: "mt-3 h-4 w-11/12 rounded-full bg-muted" }),
+          /* @__PURE__ */ jsx4("div", { className: "mt-3 h-4 w-10/12 rounded-full bg-muted" })
+        ] }),
+        /* @__PURE__ */ jsxs4("div", { className: "rounded-[24px] border border-border/70 bg-transparent px-5 py-5", children: [
+          /* @__PURE__ */ jsx4("div", { className: "h-4 w-32 rounded-full bg-muted" }),
+          /* @__PURE__ */ jsx4("div", { className: "mt-5 h-4 w-full rounded-full bg-muted" }),
+          /* @__PURE__ */ jsx4("div", { className: "mt-3 h-4 w-9/12 rounded-full bg-muted" })
+        ] })
+      ]
+    }
+  );
+}
+function IssueManagerTaskDrawerLoadingState() {
+  return /* @__PURE__ */ jsxs4("div", { "aria-hidden": "true", className: "grid gap-5", children: [
+    /* @__PURE__ */ jsx4("div", { className: "h-12 w-full rounded-2xl bg-muted" }),
+    /* @__PURE__ */ jsxs4("div", { className: "grid grid-cols-2 gap-3", children: [
+      /* @__PURE__ */ jsx4("div", { className: "h-10 rounded-xl bg-muted" }),
+      /* @__PURE__ */ jsx4("div", { className: "h-10 rounded-xl bg-muted" })
+    ] }),
+    /* @__PURE__ */ jsxs4("div", { className: "rounded-[24px] border border-border/70 bg-transparent px-4 py-4", children: [
+      /* @__PURE__ */ jsx4("div", { className: "h-4 w-24 rounded-full bg-muted" }),
+      /* @__PURE__ */ jsx4("div", { className: "mt-4 h-4 w-full rounded-full bg-muted" }),
+      /* @__PURE__ */ jsx4("div", { className: "mt-3 h-4 w-11/12 rounded-full bg-muted" }),
+      /* @__PURE__ */ jsx4("div", { className: "mt-3 h-4 w-9/12 rounded-full bg-muted" })
+    ] })
+  ] });
+}
+
+// src/ui/internal/issue/IssueManagerIssueSections.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function IssueManagerDetailTextSection({
+  body,
+  label,
+  meta,
+  tone = "muted"
+}) {
+  return /* @__PURE__ */ jsxs5("section", { className: "grid gap-2.5", children: [
+    /* @__PURE__ */ jsx5("h3", { className: "text-sm font-semibold text-foreground", children: label }),
+    /* @__PURE__ */ jsxs5("div", { className: "grid gap-1.5", children: [
+      /* @__PURE__ */ jsx5(
+        "p",
+        {
+          className: cn2(
+            "text-sm leading-6",
+            tone === "destructive" ? "text-destructive" : "text-muted-foreground"
+          ),
+          children: body
+        }
+      ),
+      meta ? /* @__PURE__ */ jsx5("p", { className: "text-xs leading-5 text-muted-foreground", children: meta }) : null
+    ] })
+  ] });
+}
+function IssueManagerOutputSection({
+  copy,
+  onOpen,
+  outputs
+}) {
+  return /* @__PURE__ */ jsxs5("section", { className: "grid gap-2.5", children: [
+    /* @__PURE__ */ jsx5("h3", { className: "text-sm font-semibold text-foreground", children: copy.t("labels.executionOutputs") }),
+    outputs.length === 0 ? /* @__PURE__ */ jsx5("p", { className: "text-sm leading-6 text-muted-foreground", children: copy.t("messages.noExecutionOutputs") }) : /* @__PURE__ */ jsx5("div", { className: "grid gap-2", children: outputs.map((output) => /* @__PURE__ */ jsxs5(
+      "button",
+      {
+        className: "flex items-start justify-between gap-4 rounded-xl border border-border/65 px-4 py-3 text-left transition-colors hover:bg-accent/18",
+        type: "button",
+        onClick: () => {
+          void onOpen({
+            displayName: output.displayName,
+            kind: "file",
+            path: output.path
+          });
+        },
+        children: [
+          /* @__PURE__ */ jsxs5("span", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsx5("span", { className: "block truncate text-sm font-semibold text-foreground", children: output.displayName }),
+            /* @__PURE__ */ jsx5("span", { className: "mt-1 block truncate text-xs text-muted-foreground", children: output.path })
+          ] }),
+          /* @__PURE__ */ jsx5("span", { className: "shrink-0 text-xs text-muted-foreground", children: formatIssueManagerTimestamp(output.createdAtUnix) || "" })
+        ]
+      },
+      output.outputId
+    )) })
+  ] });
+}
+function IssueManagerSubtaskSection({
+  copy,
+  onCreate,
+  onSelectTask,
+  selectedTaskId,
+  tasks
+}) {
+  return /* @__PURE__ */ jsxs5("section", { className: "grid gap-2.5", children: [
+    /* @__PURE__ */ jsxs5("div", { className: "flex items-center justify-between gap-3", children: [
+      /* @__PURE__ */ jsx5("h3", { className: "text-sm font-semibold text-foreground", children: copy.t("labels.subtasks") }),
+      /* @__PURE__ */ jsxs5(
+        Button5,
+        {
+          className: "px-3",
+          size: "dialog",
+          type: "button",
+          variant: "secondary",
+          onClick: onCreate,
+          children: [
+            /* @__PURE__ */ jsx5(FileCreateIcon2, { size: 14 }),
+            copy.t("actions.add")
+          ]
+        }
+      )
+    ] }),
+    tasks.length === 0 ? /* @__PURE__ */ jsx5("p", { className: "text-sm leading-6 text-muted-foreground", children: copy.t("messages.noSubtasksForIssue") }) : /* @__PURE__ */ jsx5("div", { className: "grid gap-2", children: tasks.map((task) => /* @__PURE__ */ jsxs5(
+      "button",
+      {
+        className: cn2(
+          "flex items-start justify-between gap-4 rounded-xl border px-4 py-3 text-left transition-colors",
+          selectedTaskId === task.taskId ? "border-border/90 bg-background-fronted" : "border-border/65 hover:bg-accent/18"
+        ),
+        type: "button",
+        onClick: () => onSelectTask(task.taskId),
+        children: [
+          /* @__PURE__ */ jsxs5("div", { className: "min-w-0 flex-1", children: [
+            /* @__PURE__ */ jsxs5("div", { className: "flex min-w-0 items-center gap-2.5", children: [
+              /* @__PURE__ */ jsx5("span", { className: "truncate text-sm font-semibold text-foreground", children: task.title }),
+              /* @__PURE__ */ jsx5(Badge2, { className: "rounded-md border-transparent bg-muted px-2 py-1 text-[11px] font-medium text-muted-foreground", children: resolveIssueManagerStatusLabel(copy, task.status) })
+            ] }),
+            /* @__PURE__ */ jsx5("p", { className: "mt-2 line-clamp-2 text-sm leading-6 text-muted-foreground", children: summarizeIssueManagerContent(
+              task.content,
+              copy.t("messages.taskContentEmpty")
+            ) })
+          ] }),
+          /* @__PURE__ */ jsx5("span", { className: "shrink-0 text-xs text-muted-foreground", children: formatIssueManagerTimestamp(
+            task.createdAtUnix ?? task.updatedAtUnix
+          ) || "" })
+        ]
+      },
+      task.taskId
+    )) })
+  ] });
+}
+
+// src/ui/internal/content/IssueManagerDescriptionSection.tsx
+import { useEffect as useEffect4, useRef, useState as useState3 } from "react";
+import { RichTextReadonlyContent } from "@nextop-os/ui-rich-text/editor";
+import { cn as cn3 } from "@nextop-os/ui-system";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function IssueManagerDescriptionSection({
+  content,
+  emptyLabel,
+  label,
+  minHeightClass = "min-h-[14rem]",
+  onOpen,
+  variant = "card"
+}) {
+  const contentRef = useRef(null);
+  const [isOverflowing, setIsOverflowing] = useState3(false);
+  const normalizedContent = normalizeIssueManagerContent(content).trim();
+  useEffect4(() => {
+    if (variant === "plain") {
+      setIsOverflowing(false);
+      return;
+    }
+    if (!normalizedContent) {
+      setIsOverflowing(false);
+      return;
+    }
+    const contentElement = contentRef.current;
+    if (!contentElement) {
+      return;
+    }
+    const measure = () => {
+      setIsOverflowing(
+        contentElement.scrollHeight > contentElement.clientHeight + 1
+      );
+    };
+    measure();
+    if (typeof ResizeObserver === "undefined") {
+      return;
+    }
+    const observer = new ResizeObserver(() => {
+      measure();
+    });
+    observer.observe(contentElement);
+    return () => {
+      observer.disconnect();
+    };
+  }, [normalizedContent, variant]);
+  if (variant === "plain") {
+    return /* @__PURE__ */ jsxs6("section", { className: "grid gap-2", children: [
+      /* @__PURE__ */ jsx6("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: label }),
+      normalizedContent ? /* @__PURE__ */ jsx6("div", { className: "max-w-3xl text-sm leading-5 text-text-secondary", children: /* @__PURE__ */ jsx6(
+        IssueManagerDescriptionContent,
+        {
+          content: normalizedContent,
+          onOpen
+        }
+      ) }) : /* @__PURE__ */ jsx6("p", { className: "text-sm leading-5 text-text-secondary", children: emptyLabel })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs6("section", { className: "grid gap-2", children: [
+    /* @__PURE__ */ jsx6("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: label }),
+    /* @__PURE__ */ jsxs6(
+      "div",
+      {
+        className: cn3(
+          "relative min-w-0 rounded-lg border border-border-1 bg-transparent px-4 py-3",
+          minHeightClass
+        ),
+        children: [
+          /* @__PURE__ */ jsx6(
+            "div",
+            {
+              className: cn3(
+                "max-h-[18rem] overflow-y-auto pr-2 text-sm leading-5 text-text-secondary",
+                isOverflowing && "pb-8"
+              ),
+              ref: contentRef,
+              children: normalizedContent ? /* @__PURE__ */ jsx6(
+                IssueManagerDescriptionContent,
+                {
+                  content: normalizedContent,
+                  onOpen
+                }
+              ) : /* @__PURE__ */ jsx6("p", { className: "text-text-secondary", children: emptyLabel })
+            }
+          ),
+          isOverflowing ? /* @__PURE__ */ jsx6(
+            "div",
+            {
+              className: "pointer-events-none absolute right-0 bottom-1 left-0 h-10",
+              style: {
+                background: "linear-gradient(to top, var(--background-panel), color-mix(in srgb, var(--background-panel) 80%, transparent), transparent)"
+              }
+            }
+          ) : null
+        ]
+      }
+    )
+  ] });
+}
+function IssueManagerDescriptionContent({
+  content,
+  onOpen
+}) {
+  return /* @__PURE__ */ jsx6(
+    RichTextReadonlyContent,
+    {
+      value: content,
+      onOpenWorkspaceReference: onOpen ? (reference) => onOpen({
+        displayName: reference.label,
+        kind: reference.kind,
+        path: reference.path
+      }) : void 0
+    }
+  );
+}
+
+// src/ui/internal/content/IssueManagerRichTextTextarea.tsx
+import { useMemo as useMemo5 } from "react";
+import { RichTextAtEditor } from "@nextop-os/ui-rich-text/editor";
+import { Button as Button6, LinkIcon, cn as cn4 } from "@nextop-os/ui-system";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function IssueManagerRichTextTextarea({
+  controller,
+  onChange,
+  placeholder,
+  surface,
+  textareaClassName,
+  value
+}) {
+  const providers = useMemo5(
+    () => controller.resolveRichTextAtProviders(surface),
+    [controller, surface]
+  );
+  const showReferenceAction = controller.canReferenceWorkspaceFiles;
+  return /* @__PURE__ */ jsx7(
+    RichTextAtEditor,
+    {
+      maxResults: 8,
+      minQueryLength: 1,
+      providers,
+      textOverrides: {
+        loadingLabel: controller.copy.t("richTextAt.loading"),
+        noMatchesLabel: controller.copy.t("richTextAt.noMatches"),
+        removeReferenceActionLabel: controller.copy.t("actions.removeReference")
+      },
+      textareaClassName: cn4(textareaClassName, showReferenceAction && "pb-14"),
+      placeholder,
+      value,
+      onChange,
+      overlay: showReferenceAction ? /* @__PURE__ */ jsx7("div", { className: "pointer-events-none absolute inset-x-4 bottom-3 z-10 flex", children: /* @__PURE__ */ jsxs7(
+        Button6,
+        {
+          className: "pointer-events-auto",
+          size: "sm",
+          type: "button",
+          variant: "secondary",
+          onClick: () => {
+            void controller.insertReferences(surface);
+          },
+          children: [
+            /* @__PURE__ */ jsx7(LinkIcon, { size: 14 }),
+            controller.copy.t("actions.referenceWorkspaceFiles")
+          ]
+        }
+      ) }) : null
+    }
+  );
+}
+
+// src/ui/internal/shell/IssueManagerPanels.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function IssueManagerIssuePane({
+  controller,
+  selectedIssue,
+  onDismissCreate
+}) {
+  const copy = controller.copy;
+  const isIssueTitleMissing = controller.issueDraft.title.trim().length === 0;
+  const isCreatingIssue = controller.issueEditorMode === "create";
+  const isEditingIssue = controller.issueEditorMode === "edit";
+  const issueContent = selectedIssue?.content ?? "";
+  const tasks = controller.issueDetail.value?.tasks ?? [];
+  const selectedTaskId = controller.nodeState.selectedTaskId;
+  const selectedTask = selectedTaskId ? (controller.taskDetail.value?.task?.taskId === selectedTaskId ? controller.taskDetail.value.task : tasks.find((task) => task.taskId === selectedTaskId)) ?? null : null;
+  const latestRun = selectedTask ? controller.taskDetail.value?.latestRun ?? controller.taskDetail.value?.recentRuns[0] ?? null : null;
+  const latestOutputs = selectedTask ? controller.taskDetail.value?.latestOutputs ?? [] : [];
+  if (isCreatingIssue || isEditingIssue) {
+    return /* @__PURE__ */ jsxs8("div", { className: "flex h-full min-h-0 flex-col overflow-hidden", children: [
+      /* @__PURE__ */ jsx8("div", { className: "flex min-h-0 flex-1 flex-col gap-[14px] overflow-y-auto px-7 py-8", children: /* @__PURE__ */ jsxs8("div", { className: "flex w-full min-w-0 flex-col gap-3", children: [
+        /* @__PURE__ */ jsx8("div", { children: /* @__PURE__ */ jsx8("h2", { className: "m-0 text-[17px] font-semibold leading-[1.35] text-foreground", children: isCreatingIssue ? copy.t("actions.createIssue") : copy.t("actions.editIssue") }) }),
+        /* @__PURE__ */ jsxs8("div", { className: "flex w-full min-w-0 flex-col gap-6", children: [
+          /* @__PURE__ */ jsxs8("label", { className: "flex w-full min-w-0 flex-col gap-2 text-sm font-semibold text-foreground", children: [
+            /* @__PURE__ */ jsx8("span", { className: "leading-5", children: copy.t("labels.title") }),
+            /* @__PURE__ */ jsx8(
+              Input2,
+              {
+                className: "h-10 min-h-10 rounded-lg border-border-1 bg-transparency-block px-3 text-sm font-semibold text-[var(--text-primary)] shadow-none placeholder:text-[var(--text-placeholder)]",
+                placeholder: copy.t("composer.issueTitlePlaceholder"),
+                value: controller.issueDraft.title,
+                onChange: (event) => controller.setIssueTitle(event.target.value)
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxs8("div", { className: "flex min-h-0 w-full min-w-0 flex-col gap-2 text-sm font-semibold text-foreground", children: [
+            /* @__PURE__ */ jsx8("span", { className: "leading-5", children: copy.t("labels.content") }),
+            /* @__PURE__ */ jsx8(
+              IssueManagerRichTextTextarea,
+              {
+                controller,
+                surface: "issue",
+                textareaClassName: "min-h-[180px] w-full resize-none rounded-lg border border-border-1 bg-transparency-block px-4 py-3 text-sm font-normal leading-5 text-[var(--text-primary)] outline-none placeholder:text-[var(--text-placeholder)]",
+                placeholder: copy.t("composer.issueContentPlaceholder"),
+                value: controller.issueDraft.content,
+                onChange: controller.setIssueContent
+              }
+            )
+          ] })
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsx8("div", { className: "shrink-0 border-t border-border-1 px-7 py-4", children: /* @__PURE__ */ jsxs8("div", { className: "flex items-center justify-end gap-4", children: [
+        /* @__PURE__ */ jsx8(
+          Button7,
+          {
+            size: "dialog",
+            type: "button",
+            variant: "secondary",
+            onClick: onDismissCreate,
+            children: copy.t("actions.cancel")
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          Button7,
+          {
+            disabled: isIssueTitleMissing,
+            size: "dialog",
+            type: "button",
+            onClick: () => void controller.saveIssue(),
+            children: copy.t("actions.saveIssue")
+          }
+        )
+      ] }) })
+    ] });
+  }
+  if (!selectedIssue) {
+    return /* @__PURE__ */ jsx8("div", { className: "h-full min-h-0" });
+  }
+  return /* @__PURE__ */ jsx8("div", { className: "flex min-h-0 flex-col", children: /* @__PURE__ */ jsx8("div", { className: "min-h-0 flex-1 overflow-y-auto px-8 py-7", children: controller.issueDetail.isLoading && controller.issueDetail.value === null ? /* @__PURE__ */ jsx8(IssueManagerPaneLoadingState, {}) : /* @__PURE__ */ jsxs8("div", { className: "flex w-full min-w-0 flex-col gap-9", children: [
+    /* @__PURE__ */ jsxs8("header", { className: "flex items-start justify-between gap-6", children: [
+      /* @__PURE__ */ jsxs8("div", { className: "min-w-0 flex-1", children: [
+        /* @__PURE__ */ jsx8("h2", { className: "line-clamp-2 text-base font-semibold leading-6 text-foreground", children: selectedIssue.title }),
+        /* @__PURE__ */ jsxs8("div", { className: "mt-3 flex flex-wrap items-center gap-x-5 gap-y-2 text-sm text-muted-foreground", children: [
+          /* @__PURE__ */ jsx8(Badge3, { className: "rounded-full border-transparent bg-muted px-2 py-1 text-[11px] text-muted-foreground", children: resolveIssueManagerStatusLabel(copy, selectedIssue.status) }),
+          /* @__PURE__ */ jsxs8("span", { children: [
+            copy.t("labels.creator"),
+            " ",
+            resolveIssueManagerCreatorLabel(selectedIssue)
+          ] }),
+          /* @__PURE__ */ jsxs8("span", { children: [
+            copy.t("labels.createdAt"),
+            " ",
+            formatIssueManagerTimestamp(selectedIssue.createdAtUnix) || "-"
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs8("div", { className: "flex shrink-0 items-center gap-5 pt-1", children: [
+        /* @__PURE__ */ jsx8(
+          Button7,
+          {
+            className: "h-auto px-0 text-sm font-semibold text-muted-foreground hover:text-foreground",
+            size: "sm",
+            type: "button",
+            variant: "ghost",
+            onClick: () => controller.setIssueEditorMode("edit"),
+            children: copy.t("actions.edit")
+          }
+        ),
+        /* @__PURE__ */ jsx8(
+          Button7,
+          {
+            className: "h-auto px-0 text-sm font-semibold text-destructive hover:text-destructive",
+            size: "sm",
+            type: "button",
+            variant: "ghost",
+            onClick: () => {
+              void controller.deleteIssue();
+            },
+            children: copy.t("actions.delete")
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx8(
+      IssueManagerDescriptionSection,
+      {
+        content: issueContent,
+        emptyLabel: copy.t("messages.issueContentEmpty"),
+        label: copy.t("labels.description"),
+        onOpen: controller.openReference,
+        variant: "plain"
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      IssueManagerDetailTextSection,
+      {
+        body: latestRun ? latestRun.summary?.trim() || resolveIssueManagerStatusLabel(copy, latestRun.status) : copy.t("messages.noExecutionStatus"),
+        label: copy.t("labels.latestRunStatus"),
+        meta: latestRun ? formatIssueManagerTimestamp(
+          latestRun.updatedAtUnix ?? latestRun.createdAtUnix
+        ) || void 0 : void 0,
+        tone: latestRun?.status === "failed" ? "destructive" : "muted"
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      IssueManagerOutputSection,
+      {
+        copy,
+        outputs: latestOutputs,
+        onOpen: controller.openReference
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      IssueManagerSubtaskSection,
+      {
+        copy,
+        onCreate: controller.createTaskDraft,
+        onSelectTask: controller.selectTask,
+        selectedTaskId: selectedTask?.taskId ?? null,
+        tasks
+      }
+    )
+  ] }) }) });
+}
+
+// src/ui/internal/shell/IssueManagerBottomBar.tsx
+import { Button as Button8, cn as cn5 } from "@nextop-os/ui-system";
+
+// src/ui/internal/task/IssueManagerRunSections.tsx
+import { useState as useState4 } from "react";
+import {
+  Badge as Badge4,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SparkIcon
+} from "@nextop-os/ui-system";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function IssueManagerRunActionTrigger({
+  controller,
+  disabled = false,
+  iconSize = 16,
+  triggerClassName
+}) {
+  const [resetToken, setResetToken] = useState4(0);
+  return /* @__PURE__ */ jsxs9(
+    Select,
+    {
+      disabled: controller.isRunningTask || disabled,
+      onValueChange: (provider) => {
+        setResetToken((current) => current + 1);
+        void controller.runTask(provider);
+      },
+      children: [
+        /* @__PURE__ */ jsx9(
+          SelectTrigger,
+          {
+            "aria-label": controller.copy.t("actions.askAgentToRun"),
+            className: triggerClassName,
+            children: /* @__PURE__ */ jsxs9("span", { className: "flex min-w-0 flex-1 items-center gap-2", children: [
+              /* @__PURE__ */ jsx9(SparkIcon, { size: iconSize }),
+              /* @__PURE__ */ jsx9("span", { className: "truncate", children: controller.copy.t("actions.askAgentToRun") })
+            ] })
+          }
+        ),
+        /* @__PURE__ */ jsx9(SelectContent, { style: { zIndex: "var(--z-panel-popover)" }, children: controller.providerOptions.map((provider) => /* @__PURE__ */ jsx9(SelectItem, { value: provider, children: provider }, provider)) })
+      ]
+    },
+    `${controller.nodeState.selectedAgentProvider}:${resetToken}`
+  );
+}
+function IssueManagerRunPanels({
+  copy,
+  onOpen,
+  outputs,
+  recentRuns
+}) {
+  return /* @__PURE__ */ jsxs9("div", { className: "grid gap-4", children: [
+    /* @__PURE__ */ jsxs9("section", { className: "rounded-lg border border-border-1 bg-transparent px-4 py-4", children: [
+      /* @__PURE__ */ jsx9("h4", { className: "mb-3 text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.recentRuns") }),
+      recentRuns.length === 0 ? /* @__PURE__ */ jsx9("p", { className: "text-sm leading-5 text-text-secondary", children: copy.t("messages.noRecentRuns") }) : /* @__PURE__ */ jsx9("div", { className: "grid gap-2.5", children: recentRuns.map((run) => /* @__PURE__ */ jsxs9(
+        "div",
+        {
+          className: "rounded-lg border border-[var(--border-2)] bg-transparent px-3.5 py-3",
+          children: [
+            /* @__PURE__ */ jsxs9("div", { className: "flex items-start justify-between gap-3", children: [
+              /* @__PURE__ */ jsxs9("div", { className: "min-w-0", children: [
+                /* @__PURE__ */ jsx9("p", { className: "truncate text-sm font-semibold leading-5 text-[var(--text-primary)]", children: run.summary || run.runId }),
+                /* @__PURE__ */ jsx9("p", { className: "mt-1 text-xs leading-[1.55] text-text-secondary", children: formatIssueManagerTimestamp(
+                  run.updatedAtUnix ?? run.createdAtUnix
+                ) })
+              ] }),
+              /* @__PURE__ */ jsx9(Badge4, { className: "rounded-full border-transparent bg-transparency-block px-2.5 py-1 text-xs text-text-secondary", children: resolveIssueManagerStatusLabel(copy, run.status) })
+            ] }),
+            run.errorMessage ? /* @__PURE__ */ jsx9("p", { className: "mt-2 text-xs text-destructive", children: run.errorMessage }) : null
+          ]
+        },
+        run.runId
+      )) })
+    ] }),
+    /* @__PURE__ */ jsxs9("section", { className: "rounded-lg border border-border-1 bg-transparent px-4 py-4", children: [
+      /* @__PURE__ */ jsx9("h4", { className: "mb-3 text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.outputs") }),
+      outputs.length === 0 ? /* @__PURE__ */ jsx9("p", { className: "text-sm leading-5 text-text-secondary", children: copy.t("messages.noOutputs") }) : /* @__PURE__ */ jsx9("div", { className: "grid gap-2.5", children: outputs.map((output) => /* @__PURE__ */ jsxs9(
+        "button",
+        {
+          className: "rounded-lg border border-[var(--border-2)] bg-transparent px-3.5 py-3 text-left transition-colors hover:bg-transparency-hover",
+          type: "button",
+          onClick: () => {
+            void onOpen({
+              displayName: output.displayName,
+              kind: "file",
+              path: output.path
+            });
+          },
+          children: [
+            /* @__PURE__ */ jsx9("p", { className: "truncate text-sm font-semibold leading-5 text-[var(--text-primary)]", children: output.displayName }),
+            /* @__PURE__ */ jsx9("p", { className: "mt-1 truncate text-xs leading-[1.55] text-text-secondary", children: output.path })
+          ]
+        },
+        output.outputId
+      )) })
+    ] })
+  ] });
+}
+
+// src/ui/internal/shell/IssueManagerBottomBar.tsx
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function IssueManagerBottomBar({
+  controller,
+  isNarrowLayout,
+  selectedIssue,
+  selectedTask,
+  visible
+}) {
+  const copy = controller.copy;
+  if (!visible || !selectedIssue) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx10("div", { className: "border-t border-[var(--border-1)] bg-transparent px-6 py-4 backdrop-blur", children: /* @__PURE__ */ jsxs10(
+    "div",
+    {
+      className: cn5(
+        "flex gap-3",
+        isNarrowLayout ? "flex-col items-stretch" : "items-center justify-end"
+      ),
+      children: [
+        /* @__PURE__ */ jsx10(
+          IssueManagerRunActionTrigger,
+          {
+            controller,
+            disabled: !selectedTask,
+            triggerClassName: cn5(
+              "rounded-xl border-[var(--border-1)] bg-[var(--transparency-block)] px-4 py-2",
+              isNarrowLayout ? "w-full" : "min-w-[14rem]"
+            )
+          }
+        ),
+        controller.canInviteCollaborators ? /* @__PURE__ */ jsx10(
+          Button8,
+          {
+            className: cn5("px-4", isNarrowLayout && "w-full"),
+            disabled: !selectedIssue,
+            size: "dialog",
+            type: "button",
+            onClick: () => {
+              void controller.shareSelection();
+            },
+            children: copy.t("actions.inviteCollaborator")
+          }
+        ) : null
+      ]
+    }
+  ) });
+}
+
+// src/ui/internal/shell/IssueManagerFloatingNotice.tsx
+import {
+  FailedFilledIcon,
+  Spinner,
+  toastVariants,
+  cn as cn6
+} from "@nextop-os/ui-system";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function IssueManagerFloatingNotice({
+  notice
+}) {
+  const variant = notice.tone === "destructive" ? "destructive" : "default";
+  return /* @__PURE__ */ jsx11("div", { className: "pointer-events-none absolute top-4 left-1/2 z-30 flex w-full max-w-full -translate-x-1/2 justify-center px-4", children: /* @__PURE__ */ jsx11(
+    "div",
+    {
+      "aria-busy": notice.isLoading,
+      "aria-live": variant === "destructive" ? "assertive" : "polite",
+      className: cn6(
+        toastVariants({ variant }),
+        "w-fit max-w-[min(72vw,40rem)] px-4 py-3 shadow-lg"
+      ),
+      role: variant === "destructive" ? "alert" : "status",
+      children: /* @__PURE__ */ jsxs11("div", { className: "flex min-w-0 max-w-full items-center gap-[6px] whitespace-nowrap text-sm font-normal leading-normal", children: [
+        notice.isLoading ? /* @__PURE__ */ jsx11(
+          Spinner,
+          {
+            className: "shrink-0 text-current",
+            size: 16,
+            strokeWidth: 3,
+            trackColor: "color-mix(in srgb, currentColor 28%, transparent)"
+          }
+        ) : notice.tone === "destructive" ? /* @__PURE__ */ jsx11(FailedFilledIcon, { className: "size-4 shrink-0 text-current" }) : null,
+        /* @__PURE__ */ jsx11("span", { className: "min-w-0 max-w-full truncate whitespace-nowrap", children: notice.title })
+      ] })
+    }
+  ) });
+}
+
+// src/ui/internal/shell/IssueManagerSidebar.tsx
+import { cn as cn8 } from "@nextop-os/ui-system";
+
+// src/ui/internal/shell/IssueManagerSidebarSections.tsx
+import {
+  Badge as Badge5,
+  Button as Button9,
+  CloseIcon as CloseIcon2,
+  FileCreateIcon as FileCreateIcon3,
+  Input as Input3,
+  ScrollArea as ScrollArea3,
+  UnderlineTabs,
+  cn as cn7
+} from "@nextop-os/ui-system";
+
+// src/ui/internal/shell/IssueManagerShellState.ts
+var issueManagerStatusFilters = [
+  "all",
+  "not_started",
+  "running",
+  "pending_acceptance",
+  "completed",
+  "failed",
+  "canceled"
+];
+function resolveIssueManagerSidebarViewState(input) {
+  if (input.issues.isLoading && input.issues.value.length === 0) {
+    return {
+      kind: "loading"
+    };
+  }
+  if (input.issues.error) {
+    return {
+      kind: "error",
+      retryLabel: input.copy.t("actions.refresh"),
+      title: input.copy.t("messages.issueRefreshFailed")
+    };
+  }
+  if (input.issues.value.length === 0) {
+    return {
+      body: input.copy.t("messages.noIssuesForFilterBody"),
+      kind: "empty",
+      title: input.copy.t("messages.noIssuesForFilterTitle")
+    };
+  }
+  return {
+    issues: input.issues.value,
+    kind: "list"
+  };
+}
+function buildIssueManagerStatusCounts(issues) {
+  const counts = {
+    all: issues.length,
+    canceled: 0,
+    completed: 0,
+    failed: 0,
+    not_started: 0,
+    pending_acceptance: 0,
+    running: 0
+  };
+  for (const issue of issues) {
+    if (issue.status in counts) {
+      counts[issue.status] += 1;
+    }
+  }
+  return counts;
+}
+function resolveIssueManagerShellContentViewState(input) {
+  const isIssueEditing = input.issueEditorMode !== "read";
+  const isTaskCreating = !isIssueEditing && input.taskEditorMode === "create";
+  const isTaskDrawerOpen = !isIssueEditing && !isTaskCreating && (input.taskEditorMode === "edit" || input.selectedTaskPresent);
+  return {
+    isIssueEditing,
+    isTaskCreating,
+    isTaskDrawerOpen,
+    showBottomBar: input.selectedIssue !== null && input.issueEditorMode === "read" && input.taskEditorMode === "read"
+  };
+}
+
+// src/ui/internal/shell/IssueManagerSidebarSections.tsx
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function IssueManagerSidebarHeader({
+  copy,
+  issueSearchQuery,
+  onCreateIssue,
+  onIssueSearchQueryChange
+}) {
+  return /* @__PURE__ */ jsx12("div", { className: "px-4 py-4", children: /* @__PURE__ */ jsxs12("div", { className: "flex items-center gap-2.5", children: [
+    /* @__PURE__ */ jsx12(
+      IssueManagerSearchField,
+      {
+        clearLabel: copy.t("actions.clearSearch"),
+        placeholder: copy.t("labels.searchIssues"),
+        value: issueSearchQuery,
+        onChange: onIssueSearchQueryChange
+      }
+    ),
+    /* @__PURE__ */ jsxs12(
+      Button9,
+      {
+        className: "gap-2 px-3",
+        size: "dialog",
+        type: "button",
+        variant: "secondary",
+        onClick: onCreateIssue,
+        children: [
+          /* @__PURE__ */ jsx12(FileCreateIcon3, { size: 16 }),
+          copy.t("actions.createIssue")
+        ]
+      }
+    )
+  ] }) });
+}
+function IssueManagerSidebarStatusTabs({
+  copy,
+  issueStatusFilter,
+  statusCounts,
+  onIssueStatusFilterChange
+}) {
+  return /* @__PURE__ */ jsx12(
+    UnderlineTabs,
+    {
+      ariaLabel: copy.t("labels.status"),
+      className: "px-4",
+      scrollLeftLabel: copy.t("labels.scrollStatusTabsLeft"),
+      scrollRightLabel: copy.t("labels.scrollStatusTabsRight"),
+      tabs: issueManagerStatusFilters.map((status) => ({
+        count: statusCounts[status] ?? 0,
+        label: status === "all" ? copy.t("labels.allStatus") : resolveIssueManagerStatusLabel(copy, status),
+        value: status
+      })),
+      value: issueStatusFilter,
+      onValueChange: onIssueStatusFilterChange
+    }
+  );
+}
+function IssueManagerSidebarBody({
+  copy,
+  isNarrowLayout,
+  selectedIssueId,
+  sidebarViewState,
+  onRetry,
+  onSelectIssue
+}) {
+  return /* @__PURE__ */ jsx12(
+    ScrollArea3,
+    {
+      className: cn7("min-h-0", isNarrowLayout ? "flex-none" : "h-full flex-1"),
+      children: /* @__PURE__ */ jsx12(
+        "div",
+        {
+          className: cn7(
+            "flex min-h-full flex-col gap-2.5 px-4 pt-1.5 pb-4",
+            isNarrowLayout ? "min-h-0" : "h-full"
+          ),
+          children: sidebarViewState.kind === "loading" ? /* @__PURE__ */ jsx12(IssueManagerSidebarLoadingState, { isNarrowLayout }) : sidebarViewState.kind === "error" ? /* @__PURE__ */ jsx12(
+            IssueManagerSidebarErrorState,
+            {
+              isNarrowLayout,
+              retryLabel: sidebarViewState.retryLabel,
+              title: sidebarViewState.title,
+              onRetry
+            }
+          ) : sidebarViewState.kind === "empty" ? /* @__PURE__ */ jsx12(
+            IssueManagerSidebarEmptyState,
+            {
+              body: sidebarViewState.body,
+              isNarrowLayout,
+              title: sidebarViewState.title
+            }
+          ) : /* @__PURE__ */ jsx12(
+            IssueManagerSidebarIssueList,
+            {
+              copy,
+              isNarrowLayout,
+              issues: sidebarViewState.issues,
+              selectedIssueId,
+              onSelectIssue
+            }
+          )
+        }
+      )
+    }
+  );
+}
+function IssueManagerSidebarStandalonePane({
+  body,
+  isNarrowLayout,
+  kind,
+  retryLabel,
+  title,
+  onRetry
+}) {
+  if (kind === "error" && retryLabel) {
+    return /* @__PURE__ */ jsx12(
+      IssueManagerSidebarErrorState,
+      {
+        isNarrowLayout,
+        retryLabel,
+        title,
+        onRetry
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx12(
+    IssueManagerSidebarEmptyState,
+    {
+      body: body ?? "",
+      isNarrowLayout,
+      title
+    }
+  );
+}
+function IssueManagerSearchField({
+  clearLabel,
+  onChange,
+  placeholder,
+  value
+}) {
+  return /* @__PURE__ */ jsxs12(
+    "div",
+    {
+      className: "relative min-w-0 flex-1",
+      "data-has-value": value ? "true" : "false",
+      children: [
+        /* @__PURE__ */ jsx12(
+          Input3,
+          {
+            "aria-label": placeholder,
+            className: cn7(
+              "box-border h-8 min-h-8 rounded-md border-0 bg-[var(--transparency-block)] px-3 text-sm font-normal leading-normal text-[var(--text-primary)] shadow-none outline-none ring-0 transition-colors placeholder:text-[var(--text-placeholder)] hover:bg-[var(--transparency-hover)] focus:border-0 focus:bg-[var(--transparency-hover)] focus-visible:border-0 focus-visible:bg-[var(--transparency-hover)] focus-visible:ring-0 focus-visible:ring-offset-0 disabled:bg-[var(--transparency-block)] disabled:text-[var(--text-disabled)] disabled:opacity-100",
+              "[&::-webkit-search-cancel-button]:appearance-none [&::-webkit-search-decoration]:appearance-none",
+              value ? "pr-9" : "pr-3"
+            ),
+            placeholder,
+            type: "search",
+            value,
+            onChange: (event) => onChange(event.target.value)
+          }
+        ),
+        value ? /* @__PURE__ */ jsx12(
+          "button",
+          {
+            "aria-label": clearLabel,
+            className: "absolute top-1/2 right-1 inline-flex size-6 -translate-y-1/2 items-center justify-center rounded-md border-0 bg-transparent p-0 text-[var(--text-tertiary)] transition-colors hover:bg-[var(--transparency-hover)] hover:text-[var(--text-secondary)] focus-visible:bg-[var(--transparency-hover)] focus-visible:text-[var(--text-secondary)] focus-visible:outline-none",
+            type: "button",
+            onClick: () => onChange(""),
+            onMouseDown: (event) => event.preventDefault(),
+            children: /* @__PURE__ */ jsx12(CloseIcon2, { className: "size-3.5" })
+          }
+        ) : null
+      ]
+    }
+  );
+}
+function IssueManagerSidebarIssueList({
+  copy,
+  isNarrowLayout,
+  issues,
+  selectedIssueId,
+  onSelectIssue
+}) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      className: cn7(
+        "flex gap-2.5",
+        isNarrowLayout ? "flex-row flex-nowrap items-start overflow-x-auto overflow-y-hidden [scrollbar-width:none] [&::-webkit-scrollbar]:hidden" : "flex-col"
+      ),
+      children: issues.map((issue) => /* @__PURE__ */ jsx12(
+        IssueManagerSidebarItem,
+        {
+          copy,
+          isNarrowLayout,
+          issue,
+          selected: selectedIssueId === issue.issueId,
+          onSelect: onSelectIssue
+        },
+        issue.issueId
+      ))
+    }
+  );
+}
+function IssueManagerSidebarItem({
+  copy,
+  isNarrowLayout,
+  issue,
+  onSelect,
+  selected
+}) {
+  return /* @__PURE__ */ jsxs12(
+    "button",
+    {
+      className: cn7(
+        "rounded-lg border px-3.5 py-3.5 text-left transition-colors",
+        isNarrowLayout ? "h-24 max-h-24 min-h-24 w-[clamp(220px,58vw,320px)] flex-[0_0_clamp(220px,58vw,320px)] overflow-hidden" : "w-full",
+        selected ? "border-[var(--border-1)] bg-[var(--background-fronted)]" : "border-[var(--border-1)] bg-transparent hover:bg-[var(--transparency-block)]"
+      ),
+      type: "button",
+      onClick: () => onSelect(issue.issueId),
+      children: [
+        /* @__PURE__ */ jsxs12("div", { className: "flex items-start justify-between gap-3", children: [
+          /* @__PURE__ */ jsxs12("div", { className: "min-w-0 flex-1 space-y-2", children: [
+            /* @__PURE__ */ jsx12("p", { className: "text-[12px] leading-[1.55] text-[var(--text-secondary)]", children: formatIssueManagerDate(issue.updatedAtUnix ?? issue.createdAtUnix) }),
+            /* @__PURE__ */ jsx12("p", { className: "line-clamp-4 text-[14px] font-semibold leading-[1.35rem] text-[var(--text-primary)]", children: issue.title })
+          ] }),
+          /* @__PURE__ */ jsx12(Badge5, { className: "rounded-full border-transparent bg-[var(--transparency-block)] px-2 py-1 text-[11px] text-[var(--text-secondary)]", children: resolveIssueManagerStatusLabel(copy, issue.status) })
+        ] }),
+        /* @__PURE__ */ jsx12("div", { className: "mt-2 text-[12px] leading-[1.55] text-[var(--text-secondary)]", children: copy.t("labels.taskCount", { count: issue.taskCount ?? 0 }) })
+      ]
+    }
+  );
+}
+function IssueManagerSidebarLoadingState({
+  isNarrowLayout
+}) {
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: cn7(
+        "gap-2.5",
+        isNarrowLayout ? "flex flex-row flex-nowrap overflow-x-hidden" : "grid"
+      ),
+      children: Array.from({ length: 4 }, (_, index) => /* @__PURE__ */ jsxs12(
+        "div",
+        {
+          className: cn7(
+            "rounded-lg bg-transparent px-3.5 py-3.5",
+            isNarrowLayout && "h-24 max-h-24 min-h-24 w-[clamp(220px,58vw,320px)] flex-[0_0_clamp(220px,58vw,320px)]"
+          ),
+          children: [
+            /* @__PURE__ */ jsx12("div", { className: "h-3.5 w-20 rounded-full bg-[var(--transparency-block)]" }),
+            /* @__PURE__ */ jsx12("div", { className: "mt-3 h-4 w-4/5 rounded-full bg-[var(--transparency-block)]" }),
+            /* @__PURE__ */ jsx12("div", { className: "mt-4 h-3.5 w-24 rounded-full bg-[var(--transparency-block)]" })
+          ]
+        },
+        index
+      ))
+    }
+  );
+}
+function IssueManagerSidebarEmptyState({
+  body,
+  isNarrowLayout,
+  title,
+  tone = "default"
+}) {
+  return /* @__PURE__ */ jsxs12(
+    "div",
+    {
+      className: cn7(
+        "relative flex flex-1 flex-col items-center justify-center self-stretch overflow-hidden p-0 text-center",
+        isNarrowLayout ? "h-24 max-h-24 min-h-24 w-full flex-[0_0_100%]" : "min-h-full"
+      ),
+      children: [
+        /* @__PURE__ */ jsx12(
+          "p",
+          {
+            className: cn7(
+              "text-sm font-semibold leading-5 text-[var(--text-primary)]",
+              tone === "destructive" ? "text-[var(--state-danger)]" : "text-[var(--text-primary)]"
+            ),
+            children: title
+          }
+        ),
+        /* @__PURE__ */ jsx12("p", { className: "mt-1.5 max-w-sm text-sm leading-5 text-[var(--text-secondary)]", children: body })
+      ]
+    }
+  );
+}
+function IssueManagerSidebarErrorState({
+  isNarrowLayout,
+  retryLabel,
+  title,
+  onRetry
+}) {
+  return /* @__PURE__ */ jsxs12(
+    "div",
+    {
+      className: cn7(
+        "relative flex flex-1 flex-col items-center justify-center self-stretch overflow-hidden px-4 py-6 text-center",
+        isNarrowLayout ? "h-24 max-h-24 min-h-24 w-full flex-[0_0_100%]" : "min-h-full"
+      ),
+      children: [
+        /* @__PURE__ */ jsx12("p", { className: "text-sm font-semibold leading-5 text-[var(--state-danger)]", children: title }),
+        /* @__PURE__ */ jsx12(
+          Button9,
+          {
+            className: "mt-3",
+            size: "sm",
+            type: "button",
+            variant: "secondary",
+            onClick: onRetry,
+            children: retryLabel
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/ui/internal/shell/IssueManagerSidebarState.ts
+function resolveIssueManagerSidebarPresentationState(input) {
+  const { showStandaloneState, sidebarViewState } = input;
+  if (!showStandaloneState) {
+    return { kind: "none" };
+  }
+  if (sidebarViewState.kind === "error") {
+    return {
+      kind: "error",
+      retryLabel: sidebarViewState.retryLabel,
+      title: sidebarViewState.title
+    };
+  }
+  if (sidebarViewState.kind === "empty") {
+    return {
+      body: sidebarViewState.body,
+      kind: "empty",
+      title: sidebarViewState.title
+    };
+  }
+  return { kind: "none" };
+}
+
+// src/ui/internal/shell/IssueManagerSidebar.tsx
+import { jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+function IssueManagerSidebar({
+  controller,
+  isCollapsed,
+  isNarrowLayout,
+  showStandaloneState,
+  sidebarViewState,
+  statusCounts
+}) {
+  const copy = controller.copy;
+  const presentation = resolveIssueManagerSidebarPresentationState({
+    showStandaloneState,
+    sidebarViewState
+  });
+  return /* @__PURE__ */ jsxs13(
+    "aside",
+    {
+      "aria-hidden": isCollapsed ? "true" : void 0,
+      className: cn8(
+        "absolute top-0 left-0 z-10 isolate flex h-full w-[var(--issue-manager-sidebar-width)] min-h-0 flex-col overflow-hidden bg-transparent will-change-[transform,opacity] transition-[transform,opacity,border-color] duration-[220ms] ease-[cubic-bezier(0.22,1,0.36,1)] after:pointer-events-none after:absolute after:inset-0 after:z-[1] after:bg-[color-mix(in_srgb,var(--background-panel)_88%,transparent)] after:opacity-0 after:transition-opacity after:duration-[180ms] motion-reduce:transition-none",
+        isNarrowLayout ? "border-b border-[var(--border-1)]" : "border-r border-[var(--border-1)]",
+        isCollapsed && "pointer-events-none -translate-x-full border-r-transparent opacity-0 after:opacity-100 [&>*]:opacity-0 [&>*]:transition-opacity [&>*]:duration-[120ms] motion-reduce:transform-none"
+      ),
+      inert: isCollapsed ? true : void 0,
+      children: [
+        /* @__PURE__ */ jsx13(
+          IssueManagerSidebarHeader,
+          {
+            copy,
+            issueSearchQuery: controller.nodeState.issueSearchQuery,
+            onCreateIssue: () => controller.setIssueEditorMode("create"),
+            onIssueSearchQueryChange: controller.setIssueSearchQuery
+          }
+        ),
+        /* @__PURE__ */ jsx13(
+          IssueManagerSidebarStatusTabs,
+          {
+            copy,
+            issueStatusFilter: controller.nodeState.issueStatusFilter,
+            statusCounts,
+            onIssueStatusFilterChange: controller.setIssueStatusFilter
+          }
+        ),
+        /* @__PURE__ */ jsx13("div", { "aria-hidden": "true", className: "h-2.5 flex-none" }),
+        /* @__PURE__ */ jsx13(
+          "div",
+          {
+            className: cn8(
+              "relative flex min-h-0 flex-col",
+              isNarrowLayout ? "flex-none" : "flex-1"
+            ),
+            children: presentation.kind !== "none" ? /* @__PURE__ */ jsx13("div", { className: "flex h-full min-h-0 items-center justify-center px-4 pt-1.5 pb-4", children: /* @__PURE__ */ jsx13(
+              IssueManagerSidebarStandalonePane,
+              {
+                body: presentation.kind === "empty" ? presentation.body : void 0,
+                isNarrowLayout: false,
+                kind: presentation.kind,
+                retryLabel: presentation.kind === "error" ? presentation.retryLabel : void 0,
+                title: presentation.title,
+                onRetry: () => controller.refreshAll()
+              }
+            ) }) : /* @__PURE__ */ jsx13(
+              IssueManagerSidebarBody,
+              {
+                copy,
+                isNarrowLayout,
+                selectedIssueId: controller.nodeState.selectedIssueId,
+                sidebarViewState,
+                onRetry: () => controller.refreshAll(),
+                onSelectIssue: controller.selectIssue
+              }
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+
+// src/ui/internal/shell/IssueManagerTaskComposerPane.tsx
+import {
+  Button as Button10,
+  Input as Input4,
+  Select as Select2,
+  SelectContent as SelectContent2,
+  SelectItem as SelectItem2,
+  SelectTrigger as SelectTrigger2,
+  SelectValue,
+  UploadIcon
+} from "@nextop-os/ui-system";
+import { jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+var taskPriorityOptions = ["high", "medium", "low"];
+function IssueManagerTaskComposerPane({
+  controller,
+  onCancel,
+  selectedIssue
+}) {
+  const copy = controller.copy;
+  const isTaskTitleMissing = controller.taskDraft.title.trim().length === 0;
+  const showAttachmentActions = controller.canUploadWorkspaceFiles || controller.canReferenceWorkspaceFiles;
+  return /* @__PURE__ */ jsxs14("div", { className: "flex h-full min-h-0 flex-col overflow-hidden", children: [
+    /* @__PURE__ */ jsx14("div", { className: "min-h-0 flex-1 overflow-y-auto px-7 py-8", children: /* @__PURE__ */ jsxs14("div", { className: "flex w-full max-w-[76rem] flex-col gap-8", children: [
+      /* @__PURE__ */ jsxs14("div", { className: "flex items-start justify-between gap-4", children: [
+        /* @__PURE__ */ jsx14("h2", { className: "text-[17px] font-semibold leading-[1.35] text-[var(--text-primary)]", children: copy.t("actions.addSubtask") }),
+        /* @__PURE__ */ jsxs14("div", { className: "flex items-center gap-3", children: [
+          /* @__PURE__ */ jsx14("span", { className: "text-sm text-text-secondary", children: copy.t("labels.priority") }),
+          /* @__PURE__ */ jsxs14(
+            Select2,
+            {
+              value: controller.taskDraft.priority,
+              onValueChange: (value) => controller.setTaskPriority(value),
+              children: [
+                /* @__PURE__ */ jsx14(
+                  SelectTrigger2,
+                  {
+                    "aria-label": copy.t("labels.priority"),
+                    className: "min-w-28 rounded-lg border-border-1 bg-transparency-block text-sm",
+                    children: /* @__PURE__ */ jsx14(SelectValue, {})
+                  }
+                ),
+                /* @__PURE__ */ jsx14(SelectContent2, { style: { zIndex: "var(--z-panel-popover)" }, children: taskPriorityOptions.map((priority) => /* @__PURE__ */ jsx14(SelectItem2, { value: priority, children: resolveIssueManagerPriorityLabel(copy, priority) }, priority)) })
+              ]
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs14("label", { className: "grid gap-2", children: [
+        /* @__PURE__ */ jsx14("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.title") }),
+        /* @__PURE__ */ jsx14(
+          Input4,
+          {
+            className: "h-10 rounded-lg border-0 bg-transparency-block px-3 text-sm font-semibold text-[var(--text-primary)] shadow-none placeholder:text-[var(--text-placeholder)]",
+            placeholder: copy.t("composer.subtaskTitlePlaceholder"),
+            value: controller.taskDraft.title,
+            onChange: (event) => controller.setTaskTitle(event.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs14("section", { className: "grid gap-2", children: [
+        /* @__PURE__ */ jsx14("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.requirementDescription") }),
+        /* @__PURE__ */ jsxs14("div", { className: "overflow-hidden rounded-lg border border-border-1 bg-transparency-block", children: [
+          /* @__PURE__ */ jsx14(
+            IssueManagerRichTextTextarea,
+            {
+              controller,
+              surface: "task",
+              textareaClassName: "min-h-[20rem] w-full resize-none border-0 bg-transparent px-4 py-3 text-sm leading-5 text-[var(--text-primary)] outline-none placeholder:text-[var(--text-placeholder)]",
+              placeholder: copy.t("composer.subtaskContentPlaceholder"),
+              value: controller.taskDraft.content,
+              onChange: controller.setTaskContent
+            }
+          ),
+          showAttachmentActions ? /* @__PURE__ */ jsxs14("div", { className: "flex flex-wrap items-center gap-3 border-t border-border-1 px-4 py-3", children: [
+            controller.canUploadWorkspaceFiles ? /* @__PURE__ */ jsxs14(
+              Button10,
+              {
+                className: "px-3",
+                size: "dialog",
+                type: "button",
+                variant: "secondary",
+                onClick: () => {
+                  void controller.uploadReferences("task", "files");
+                },
+                children: [
+                  /* @__PURE__ */ jsx14(UploadIcon, { size: 16 }),
+                  copy.t("actions.uploadFiles")
+                ]
+              }
+            ) : null,
+            controller.canUploadWorkspaceFiles ? /* @__PURE__ */ jsxs14(
+              Button10,
+              {
+                className: "px-3",
+                size: "dialog",
+                type: "button",
+                variant: "secondary",
+                onClick: () => {
+                  void controller.uploadReferences("task", "folder");
+                },
+                children: [
+                  /* @__PURE__ */ jsx14(UploadIcon, { size: 16 }),
+                  copy.t("actions.uploadFolder")
+                ]
+              }
+            ) : null
+          ] }) : null
+        ] })
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx14("div", { className: "shrink-0 border-t border-border-1 px-7 py-4", children: /* @__PURE__ */ jsxs14("div", { className: "flex items-center justify-end gap-3", children: [
+      /* @__PURE__ */ jsx14(
+        Button10,
+        {
+          size: "default",
+          type: "button",
+          variant: "secondary",
+          onClick: onCancel,
+          children: copy.t("actions.cancel")
+        }
+      ),
+      /* @__PURE__ */ jsx14(
+        Button10,
+        {
+          disabled: !selectedIssue || isTaskTitleMissing,
+          size: "default",
+          type: "button",
+          onClick: () => void controller.saveTask(),
+          children: copy.t("actions.saveSubtask")
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/ui/internal/shell/IssueManagerTaskDrawer.tsx
+import { ScrollArea as ScrollArea4 } from "@nextop-os/ui-system";
+
+// src/ui/internal/shell/IssueManagerTaskDrawerSections.tsx
+import {
+  Badge as Badge6,
+  Button as Button12,
+  CloseIcon as CloseIcon3,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+  Input as Input5,
+  Select as Select3,
+  SelectContent as SelectContent3,
+  SelectItem as SelectItem3,
+  SelectTrigger as SelectTrigger3,
+  SelectValue as SelectValue2,
+  SparkIcon as SparkIcon2
+} from "@nextop-os/ui-system";
+
+// src/ui/internal/content/IssueManagerContextSection.tsx
+import { Button as Button11, DirectoryIcon as DirectoryIcon3, FileIcon as FileIcon3 } from "@nextop-os/ui-system";
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+function IssueManagerContextSection({
+  copy,
+  emptyLabel,
+  onAdd,
+  onOpen,
+  onRemove,
+  refs
+}) {
+  return /* @__PURE__ */ jsxs15("section", { className: "rounded-lg border border-border-1 bg-transparent px-4 py-4", children: [
+    /* @__PURE__ */ jsxs15("div", { className: "mb-3 flex items-center justify-between gap-3", children: [
+      /* @__PURE__ */ jsx15("h4", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.contextReferences") }),
+      /* @__PURE__ */ jsx15(
+        Button11,
+        {
+          className: "px-3",
+          size: "dialog",
+          type: "button",
+          variant: "secondary",
+          onClick: onAdd,
+          children: copy.t("actions.addReferences")
+        }
+      )
+    ] }),
+    refs.length === 0 ? /* @__PURE__ */ jsx15("p", { className: "text-sm leading-5 text-text-secondary", children: emptyLabel }) : /* @__PURE__ */ jsx15("div", { className: "grid gap-2.5", children: refs.map((ref) => /* @__PURE__ */ jsxs15(
+      "div",
+      {
+        className: "flex items-center justify-between gap-3 rounded-lg border border-[var(--border-2)] bg-transparent px-3.5 py-3",
+        children: [
+          /* @__PURE__ */ jsxs15(
+            "button",
+            {
+              className: "flex min-w-0 flex-1 items-center gap-3 text-left",
+              type: "button",
+              onClick: () => {
+                void onOpen({
+                  displayName: ref.displayName,
+                  kind: ref.path.endsWith("/") ? "folder" : "file",
+                  path: ref.path
+                });
+              },
+              children: [
+                ref.path.endsWith("/") ? /* @__PURE__ */ jsx15(
+                  DirectoryIcon3,
+                  {
+                    className: "shrink-0 text-text-secondary",
+                    size: 16
+                  }
+                ) : /* @__PURE__ */ jsx15(
+                  FileIcon3,
+                  {
+                    className: "shrink-0 text-text-secondary",
+                    size: 16
+                  }
+                ),
+                /* @__PURE__ */ jsxs15("span", { className: "min-w-0", children: [
+                  /* @__PURE__ */ jsx15("span", { className: "block truncate text-sm font-semibold leading-5 text-[var(--text-primary)]", children: ref.displayName }),
+                  /* @__PURE__ */ jsx15("span", { className: "block truncate text-xs leading-[1.55] text-text-secondary", children: ref.path })
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx15(
+            Button11,
+            {
+              className: "h-7 rounded-md px-2 text-[13px] font-semibold text-text-secondary hover:text-[var(--text-primary)]",
+              size: "sm",
+              type: "button",
+              variant: "ghost",
+              onClick: () => {
+                void onRemove(ref);
+              },
+              children: copy.t("actions.removeReference")
+            }
+          )
+        ]
+      },
+      ref.contextRefId
+    )) })
+  ] });
+}
+
+// src/ui/internal/shell/IssueManagerTaskDrawerState.ts
+function resolveIssueManagerTaskDrawerViewState(input) {
+  const { controller, selectedTask } = input;
+  const isCreate = controller.taskEditorMode === "create";
+  const isEdit = controller.taskEditorMode === "edit";
+  const isRead = !isCreate && !isEdit;
+  const showTaskMetadata = isRead && selectedTask !== null;
+  const bodyKind = controller.taskDetail.isLoading && isCreate === false && controller.taskDetail.value === null ? "loading" : isCreate || isEdit ? "edit" : "read";
+  return {
+    bodyKind,
+    isCreate,
+    isEdit,
+    isRead,
+    isTaskTitleMissing: controller.taskDraft.title.trim().length === 0,
+    showEditFooter: isCreate || isEdit,
+    showReadFooter: showTaskMetadata,
+    showTaskActions: showTaskMetadata,
+    showTaskMetadata,
+    title: isCreate || isEdit ? isCreate ? controller.copy.t("actions.createTask") : controller.copy.t("actions.editTask") : selectedTask?.title || controller.copy.t("labels.taskDetails")
+  };
+}
+function resolveIssueManagerTaskRefs(input) {
+  return input.controller.taskDetail.value?.contextRefs.filter(
+    (ref) => ref.parentKind === "task"
+  ) ?? [];
+}
+function canIssueManagerSaveTask(input) {
+  return input.selectedIssue !== null && input.view.isTaskTitleMissing === false;
+}
+
+// src/ui/internal/shell/IssueManagerTaskDrawerSections.tsx
+import { Fragment, jsx as jsx16, jsxs as jsxs16 } from "react/jsx-runtime";
+var taskPriorityOptions2 = ["high", "medium", "low"];
+function IssueManagerTaskDrawerHeader({
+  controller,
+  selectedTask,
+  view,
+  onClose
+}) {
+  const copy = controller.copy;
+  return /* @__PURE__ */ jsxs16("div", { className: "flex items-start justify-between gap-4 border-b border-border-1 px-7 py-5", children: [
+    /* @__PURE__ */ jsxs16("div", { className: "min-w-0 flex-1", children: [
+      view.showTaskMetadata && selectedTask ? /* @__PURE__ */ jsx16("div", { className: "grid min-w-0 gap-2", children: /* @__PURE__ */ jsx16("h3", { className: "line-clamp-3 text-sm font-semibold leading-[1.35] text-[var(--text-primary)]", children: view.title }) }) : /* @__PURE__ */ jsx16("h3", { className: "line-clamp-2 text-[17px] font-semibold leading-[1.35] text-[var(--text-primary)]", children: view.title }),
+      view.showTaskMetadata && selectedTask ? /* @__PURE__ */ jsxs16("div", { className: "mt-2 flex min-w-0 items-center overflow-hidden text-sm leading-[1.55] text-text-secondary", children: [
+        /* @__PURE__ */ jsx16(Badge6, { className: "shrink-0 rounded-full border-transparent bg-[var(--accent-bg)] px-2.5 py-1 text-xs text-[var(--text-primary)]", children: resolveIssueManagerStatusLabel(copy, selectedTask.status) }),
+        /* @__PURE__ */ jsx16("span", { className: "mx-3 h-[13px] w-px shrink-0 bg-border-1" }),
+        /* @__PURE__ */ jsx16(Badge6, { className: "shrink-0 rounded-full border-transparent bg-transparency-block px-2.5 py-1 text-xs text-text-secondary", children: resolveIssueManagerPriorityLabel(copy, selectedTask.priority) }),
+        /* @__PURE__ */ jsx16("span", { className: "mx-3 h-[13px] w-px shrink-0 bg-border-1" }),
+        /* @__PURE__ */ jsxs16("span", { children: [
+          copy.t("labels.updatedAt"),
+          " ",
+          formatIssueManagerTimestamp(
+            selectedTask.updatedAtUnix ?? selectedTask.createdAtUnix
+          ) || "-"
+        ] }),
+        /* @__PURE__ */ jsx16("span", { className: "mx-3 h-[13px] w-px shrink-0 bg-border-1" }),
+        /* @__PURE__ */ jsx16("span", { className: "min-w-0 truncate", children: resolveTaskCreatorLabel(selectedTask) })
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsxs16("div", { className: "flex shrink-0 items-center gap-2", children: [
+      view.showTaskActions && selectedTask ? /* @__PURE__ */ jsxs16(DropdownMenu, { children: [
+        /* @__PURE__ */ jsx16(DropdownMenuTrigger, { asChild: true, children: /* @__PURE__ */ jsx16(
+          Button12,
+          {
+            "aria-label": copy.t("actions.moreActions"),
+            size: "icon-sm",
+            type: "button",
+            variant: "ghost",
+            children: /* @__PURE__ */ jsx16(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: "text-base leading-none tracking-[0.18em] text-text-secondary",
+                children: "..."
+              }
+            )
+          }
+        ) }),
+        /* @__PURE__ */ jsxs16(DropdownMenuContent, { align: "end", sideOffset: 8, children: [
+          /* @__PURE__ */ jsx16(
+            DropdownMenuItem,
+            {
+              onClick: () => controller.setTaskEditorMode("edit"),
+              children: copy.t("actions.editTask")
+            }
+          ),
+          /* @__PURE__ */ jsx16(
+            DropdownMenuItem,
+            {
+              variant: "destructive",
+              onClick: () => {
+                void controller.deleteTask();
+              },
+              children: copy.t("actions.deleteTask")
+            }
+          )
+        ] })
+      ] }) : null,
+      /* @__PURE__ */ jsx16(
+        Button12,
+        {
+          "aria-label": copy.t("actions.cancel"),
+          size: "icon-sm",
+          type: "button",
+          variant: "ghost",
+          onClick: onClose,
+          children: /* @__PURE__ */ jsx16(CloseIcon3, { size: 16 })
+        }
+      )
+    ] })
+  ] });
+}
+function IssueManagerTaskDrawerLoadingBody() {
+  return /* @__PURE__ */ jsx16(IssueManagerTaskDrawerLoadingState, {});
+}
+function IssueManagerTaskDrawerBody({
+  controller,
+  taskContent,
+  taskRefs,
+  view
+}) {
+  if (view.bodyKind === "loading") {
+    return /* @__PURE__ */ jsx16(IssueManagerTaskDrawerLoadingBody, {});
+  }
+  if (view.bodyKind === "edit") {
+    return /* @__PURE__ */ jsx16(
+      IssueManagerTaskDrawerEditBody,
+      {
+        controller,
+        isCreate: view.isCreate,
+        taskRefs
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx16(
+    IssueManagerTaskDrawerReadBody,
+    {
+      controller,
+      taskContent,
+      taskRefs
+    }
+  );
+}
+function IssueManagerTaskDrawerEditBody({
+  controller,
+  isCreate,
+  taskRefs
+}) {
+  const copy = controller.copy;
+  return /* @__PURE__ */ jsxs16(Fragment, { children: [
+    /* @__PURE__ */ jsxs16("div", { className: "grid gap-5", children: [
+      /* @__PURE__ */ jsxs16("label", { className: "grid gap-2", children: [
+        /* @__PURE__ */ jsx16("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.title") }),
+        /* @__PURE__ */ jsx16(
+          Input5,
+          {
+            className: "h-10 rounded-lg border-border-1 bg-transparency-block text-sm font-semibold text-[var(--text-primary)] shadow-none placeholder:text-[var(--text-placeholder)]",
+            placeholder: copy.t("composer.taskTitlePlaceholder"),
+            value: controller.taskDraft.title,
+            onChange: (event) => controller.setTaskTitle(event.target.value)
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsx16("div", { className: "flex flex-wrap items-center gap-3", children: /* @__PURE__ */ jsxs16("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx16("span", { className: "text-sm font-medium text-text-secondary", children: copy.t("labels.priority") }),
+        /* @__PURE__ */ jsxs16(
+          Select3,
+          {
+            value: controller.taskDraft.priority,
+            onValueChange: (value) => controller.setTaskPriority(value),
+            children: [
+              /* @__PURE__ */ jsx16(
+                SelectTrigger3,
+                {
+                  "aria-label": copy.t("labels.priority"),
+                  className: "min-w-28 rounded-lg border-border-1 bg-transparency-block text-sm",
+                  children: /* @__PURE__ */ jsx16(SelectValue2, {})
+                }
+              ),
+              /* @__PURE__ */ jsx16(SelectContent3, { style: { zIndex: "var(--z-panel-popover)" }, children: taskPriorityOptions2.map((priority) => /* @__PURE__ */ jsx16(SelectItem3, { value: priority, children: resolveIssueManagerPriorityLabel(copy, priority) }, priority)) })
+            ]
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ jsxs16("div", { className: "grid gap-2", children: [
+        /* @__PURE__ */ jsx16("span", { className: "text-sm font-semibold leading-5 text-[var(--text-primary)]", children: copy.t("labels.content") }),
+        /* @__PURE__ */ jsx16(
+          IssueManagerRichTextTextarea,
+          {
+            controller,
+            surface: "task",
+            textareaClassName: "min-h-[12rem] w-full resize-none rounded-lg border border-border-1 bg-transparency-block px-4 py-3 text-sm leading-5 text-[var(--text-primary)] outline-none placeholder:text-[var(--text-placeholder)]",
+            placeholder: copy.t("composer.taskContentPlaceholder"),
+            value: controller.taskDraft.content,
+            onChange: controller.setTaskContent
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx16(
+      IssueManagerContextSection,
+      {
+        copy,
+        emptyLabel: copy.t("messages.noTaskReferences"),
+        refs: taskRefs,
+        onAdd: () => {
+          void controller.attachReferences("task");
+        },
+        onOpen: controller.openReference,
+        onRemove: controller.removeContextRef
+      }
+    ),
+    !isCreate ? /* @__PURE__ */ jsx16(
+      IssueManagerRunPanels,
+      {
+        copy,
+        outputs: controller.taskDetail.value?.latestOutputs ?? [],
+        recentRuns: controller.taskDetail.value?.recentRuns ?? [],
+        onOpen: controller.openReference
+      }
+    ) : null
+  ] });
+}
+function IssueManagerTaskDrawerReadBody({
+  controller,
+  taskContent,
+  taskRefs
+}) {
+  const copy = controller.copy;
+  return /* @__PURE__ */ jsxs16(Fragment, { children: [
+    /* @__PURE__ */ jsx16(
+      IssueManagerDescriptionSection,
+      {
+        content: taskContent,
+        emptyLabel: copy.t("messages.taskContentEmpty"),
+        label: copy.t("labels.content"),
+        minHeightClass: "min-h-[8rem]",
+        onOpen: controller.openReference
+      }
+    ),
+    /* @__PURE__ */ jsx16(
+      IssueManagerContextSection,
+      {
+        copy,
+        emptyLabel: copy.t("messages.noTaskReferences"),
+        refs: taskRefs,
+        onAdd: () => {
+          void controller.attachReferences("task");
+        },
+        onOpen: controller.openReference,
+        onRemove: controller.removeContextRef
+      }
+    ),
+    /* @__PURE__ */ jsx16(
+      IssueManagerRunPanels,
+      {
+        copy,
+        outputs: controller.taskDetail.value?.latestOutputs ?? [],
+        recentRuns: controller.taskDetail.value?.recentRuns ?? [],
+        onOpen: controller.openReference
+      }
+    )
+  ] });
+}
+function IssueManagerTaskDrawerFooter({
+  controller,
+  selectedIssue,
+  selectedTask,
+  view
+}) {
+  const copy = controller.copy;
+  if (view.showReadFooter && selectedTask) {
+    return /* @__PURE__ */ jsx16("div", { className: "border-t border-border-1 px-7 py-4", children: /* @__PURE__ */ jsxs16("div", { className: "flex items-center justify-between gap-3", children: [
+      /* @__PURE__ */ jsx16(
+        IssueManagerRunActionTrigger,
+        {
+          controller,
+          iconSize: 15,
+          triggerClassName: "min-w-[11rem] rounded-lg border-border-1 bg-transparency-block px-3.5 py-2 text-sm"
+        }
+      ),
+      controller.canInviteCollaborators ? /* @__PURE__ */ jsx16(
+        Button12,
+        {
+          className: "shrink-0 px-4",
+          size: "dialog",
+          type: "button",
+          onClick: () => {
+            void controller.shareSelection();
+          },
+          children: copy.t("actions.inviteCollaborator")
+        }
+      ) : null
+    ] }) });
+  }
+  if (view.showEditFooter) {
+    return /* @__PURE__ */ jsx16("div", { className: "border-t border-border-1 px-7 py-4", children: /* @__PURE__ */ jsxs16("div", { className: "flex items-center justify-between gap-3", children: [
+      /* @__PURE__ */ jsx16("div", { className: "flex items-center gap-2", children: !view.isCreate && selectedTask ? /* @__PURE__ */ jsx16(
+        Button12,
+        {
+          size: "default",
+          type: "button",
+          variant: "destructive",
+          onClick: () => {
+            void controller.deleteTask();
+          },
+          children: copy.t("actions.deleteTask")
+        }
+      ) : null }),
+      /* @__PURE__ */ jsxs16("div", { className: "flex items-center gap-3", children: [
+        /* @__PURE__ */ jsx16(
+          Button12,
+          {
+            size: "default",
+            type: "button",
+            variant: "secondary",
+            onClick: () => controller.setTaskEditorMode("read"),
+            children: copy.t("actions.cancel")
+          }
+        ),
+        /* @__PURE__ */ jsxs16(
+          Button12,
+          {
+            disabled: canIssueManagerSaveTask({
+              selectedIssue,
+              view
+            }) === false,
+            size: "default",
+            type: "button",
+            onClick: () => void controller.saveTask(),
+            children: [
+              /* @__PURE__ */ jsx16(SparkIcon2, { size: 16 }),
+              copy.t("actions.saveTask")
+            ]
+          }
+        )
+      ] })
+    ] }) });
+  }
+  return null;
+}
+
+// src/ui/internal/shell/IssueManagerTaskDrawer.tsx
+import { jsx as jsx17, jsxs as jsxs17 } from "react/jsx-runtime";
+function IssueManagerTaskDrawer({
+  controller,
+  selectedIssue,
+  selectedTask,
+  onClose
+}) {
+  const view = resolveIssueManagerTaskDrawerViewState({
+    controller,
+    selectedTask
+  });
+  const taskRefs = resolveIssueManagerTaskRefs({ controller });
+  const taskContent = selectedTask?.content ?? "";
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      className: "absolute inset-0 z-20 flex justify-end bg-[var(--backdrop)] backdrop-blur-[1px]",
+      onClick: onClose,
+      children: /* @__PURE__ */ jsxs17(
+        "aside",
+        {
+          className: "flex h-full w-[34rem] max-w-[92vw] flex-col border-l border-border-1 bg-background-panel text-[var(--text-primary)] shadow-[-20px_0_60px_var(--shadow-elevated)]",
+          onClick: (event) => event.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsx17(
+              IssueManagerTaskDrawerHeader,
+              {
+                controller,
+                selectedTask,
+                view,
+                onClose
+              }
+            ),
+            /* @__PURE__ */ jsx17(ScrollArea4, { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx17("div", { className: "flex flex-col gap-5 px-7 py-6", children: /* @__PURE__ */ jsx17(
+              IssueManagerTaskDrawerBody,
+              {
+                controller,
+                taskContent,
+                taskRefs,
+                view
+              }
+            ) }) }),
+            /* @__PURE__ */ jsx17(
+              IssueManagerTaskDrawerFooter,
+              {
+                controller,
+                selectedIssue,
+                selectedTask,
+                view
+              }
+            )
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/ui/internal/shell/useIssueManagerShellView.ts
+import {
+  useEffect as useEffect5,
+  useEffectEvent as useEffectEvent3,
+  useRef as useRef2,
+  useState as useState5
+} from "react";
+function useIssueManagerShellView({
+  controller,
+  selectedIssue,
+  selectedTask
+}) {
+  const layoutRef = useRef2(null);
+  const resizeRef = useRef2(null);
+  const [sidebarWidth, setSidebarWidth] = useState5(
+    issueManagerSidebarDefaultWidth
+  );
+  const [isNarrowLayout, setIsNarrowLayout] = useState5(false);
+  const dismissNotification = useEffectEvent3(() => {
+    controller.dismissNotification();
+  });
+  const floatingNotice = controller.floatingNotice;
+  useEffect5(() => {
+    const publishLayout = () => {
+      const width = layoutRef.current?.getBoundingClientRect().width ?? 0;
+      if (!width) {
+        return;
+      }
+      setSidebarWidth(
+        (current) => clampIssueManagerSidebarWidth(current, width)
+      );
+      setIsNarrowLayout(shouldAutoCollapseIssueManagerSidebar(width));
+    };
+    const layout = layoutRef.current;
+    const observer = layout && typeof ResizeObserver !== "undefined" ? new ResizeObserver(publishLayout) : null;
+    publishLayout();
+    if (observer && layout) {
+      observer.observe(layout);
+    }
+    window.addEventListener("resize", publishLayout);
+    return () => {
+      observer?.disconnect();
+      window.removeEventListener("resize", publishLayout);
+    };
+  }, []);
+  useEffect5(() => {
+    if (!floatingNotice) {
+      return void 0;
+    }
+    const timeout = window.setTimeout(() => {
+      dismissNotification();
+    }, floatingNotice.durationMs);
+    return () => {
+      window.clearTimeout(timeout);
+    };
+  }, [dismissNotification, floatingNotice]);
+  const content = resolveIssueManagerShellContentViewState({
+    issueEditorMode: controller.issueEditorMode,
+    selectedIssue,
+    selectedTaskPresent: selectedTask !== null,
+    taskEditorMode: controller.taskEditorMode
+  });
+  const sidebarViewState = resolveIssueManagerSidebarViewState({
+    copy: controller.copy,
+    issues: controller.issues
+  });
+  const statusCounts = buildIssueManagerStatusCounts(controller.issues.value);
+  const isSidebarAutoCollapsed = isNarrowLayout;
+  const isSidebarCollapsed = controller.nodeState.taskListCollapsed === true || isSidebarAutoCollapsed;
+  return {
+    content,
+    floatingNotice,
+    isNarrowLayout,
+    layoutRef,
+    layoutStyle: {
+      "--issue-manager-sidebar-width": `${sidebarWidth}px`
+    },
+    resizeHandle: {
+      ariaValueMax: issueManagerSidebarMaxWidth,
+      ariaValueMin: issueManagerSidebarMinWidth,
+      ariaValueNow: sidebarWidth,
+      onKeyDown: (event) => {
+        if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") {
+          return;
+        }
+        const delta = event.key === "ArrowRight" ? 16 : -16;
+        const layoutWidth = layoutRef.current?.getBoundingClientRect().width ?? 0;
+        if (!layoutWidth) {
+          return;
+        }
+        event.preventDefault();
+        setSidebarWidth(
+          (current) => clampIssueManagerSidebarWidth(current + delta, layoutWidth)
+        );
+      },
+      onPointerCancel: (event) => {
+        resizeRef.current = null;
+        event.currentTarget.releasePointerCapture?.(event.pointerId);
+      },
+      onPointerDown: (event) => {
+        if (event.button !== 0) {
+          return;
+        }
+        const layoutWidth = layoutRef.current?.getBoundingClientRect().width ?? 0;
+        if (!layoutWidth) {
+          return;
+        }
+        const startWidth = clampIssueManagerSidebarWidth(
+          sidebarWidth,
+          layoutWidth
+        );
+        resizeRef.current = {
+          maxWidth: clampIssueManagerSidebarWidth(
+            issueManagerSidebarMaxWidth,
+            layoutWidth
+          ),
+          pointerId: event.pointerId,
+          startClientX: event.clientX,
+          startWidth
+        };
+        setSidebarWidth(startWidth);
+        event.currentTarget.setPointerCapture?.(event.pointerId);
+      },
+      onPointerMove: (event) => {
+        const state = resizeRef.current;
+        if (!state || state.pointerId !== event.pointerId) {
+          return;
+        }
+        setSidebarWidth(
+          Math.min(
+            Math.max(
+              state.startWidth + event.clientX - state.startClientX,
+              issueManagerSidebarMinWidth
+            ),
+            state.maxWidth
+          )
+        );
+      },
+      onPointerUp: (event) => {
+        resizeRef.current = null;
+        event.currentTarget.releasePointerCapture?.(event.pointerId);
+      }
+    },
+    sidebar: {
+      isAutoCollapsed: isSidebarAutoCollapsed,
+      isCollapsed: isSidebarCollapsed,
+      showStandaloneState: !isNarrowLayout && (sidebarViewState.kind === "empty" || sidebarViewState.kind === "error"),
+      statusCounts,
+      viewState: sidebarViewState
+    }
+  };
+}
+
+// src/ui/internal/shell/IssueManagerShell.tsx
+import { jsx as jsx18, jsxs as jsxs18 } from "react/jsx-runtime";
+function IssueManagerShell({
+  controller,
+  onCloseTaskDrawer,
+  onDismissIssueCreate,
+  selectedIssue,
+  selectedTask
+}) {
+  const shellView = useIssueManagerShellView({
+    controller,
+    selectedIssue,
+    selectedTask
+  });
+  return /* @__PURE__ */ jsxs18(
+    "div",
+    {
+      className: "relative min-h-0 flex-1 overflow-hidden bg-transparent",
+      "data-issue-manager-sidebar-auto-collapsed": shellView.sidebar.isAutoCollapsed ? "true" : void 0,
+      "data-issue-manager-sidebar-collapsed": shellView.sidebar.isCollapsed ? "true" : void 0,
+      ref: shellView.layoutRef,
+      style: shellView.layoutStyle,
+      children: [
+        shellView.floatingNotice ? /* @__PURE__ */ jsx18(IssueManagerFloatingNotice, { notice: shellView.floatingNotice }) : null,
+        /* @__PURE__ */ jsx18(
+          IssueManagerSidebar,
+          {
+            controller,
+            isCollapsed: shellView.sidebar.isCollapsed,
+            isNarrowLayout: shellView.isNarrowLayout,
+            showStandaloneState: shellView.sidebar.showStandaloneState,
+            sidebarViewState: shellView.sidebar.viewState,
+            statusCounts: shellView.sidebar.statusCounts
+          }
+        ),
+        shellView.sidebar.isCollapsed ? null : /* @__PURE__ */ jsx18(
+          "div",
+          {
+            "aria-label": controller.copy.t("labels.resizeIssueList"),
+            "aria-orientation": "vertical",
+            "aria-valuemax": shellView.resizeHandle.ariaValueMax,
+            "aria-valuemin": shellView.resizeHandle.ariaValueMin,
+            "aria-valuenow": shellView.resizeHandle.ariaValueNow,
+            className: "group absolute top-0 bottom-0 left-[calc(var(--issue-manager-sidebar-width)-6px)] z-20 w-3 cursor-col-resize touch-none",
+            role: "separator",
+            tabIndex: 0,
+            onKeyDown: shellView.resizeHandle.onKeyDown,
+            onPointerCancel: shellView.resizeHandle.onPointerCancel,
+            onPointerDown: shellView.resizeHandle.onPointerDown,
+            onPointerMove: shellView.resizeHandle.onPointerMove,
+            onPointerUp: shellView.resizeHandle.onPointerUp,
+            children: /* @__PURE__ */ jsx18("span", { className: "absolute top-0 bottom-0 left-1/2 w-px -translate-x-1/2 bg-transparent transition-[background-color,width] duration-150 group-hover:w-0.5 group-hover:bg-[color-mix(in_srgb,var(--border-focus)_40%,transparent)] group-focus-visible:w-0.5 group-focus-visible:bg-[color-mix(in_srgb,var(--border-focus)_40%,transparent)]" })
+          }
+        ),
+        /* @__PURE__ */ jsxs18(
+          "div",
+          {
+            className: cn9(
+              "relative min-h-0 h-full overflow-hidden bg-transparent",
+              !shellView.sidebar.isCollapsed && "pl-[var(--issue-manager-sidebar-width)]"
+            ),
+            children: [
+              /* @__PURE__ */ jsxs18("div", { className: "flex h-full min-h-0 flex-col", children: [
+                /* @__PURE__ */ jsx18("div", { className: "min-h-0 flex-1 overflow-hidden", children: shellView.content.isIssueEditing ? /* @__PURE__ */ jsx18(
+                  IssueManagerIssuePane,
+                  {
+                    controller,
+                    selectedIssue,
+                    onDismissCreate: onDismissIssueCreate
+                  }
+                ) : shellView.content.isTaskCreating ? /* @__PURE__ */ jsx18(
+                  IssueManagerTaskComposerPane,
+                  {
+                    controller,
+                    selectedIssue,
+                    onCancel: () => controller.setTaskEditorMode("read")
+                  }
+                ) : selectedIssue ? /* @__PURE__ */ jsx18(
+                  IssueManagerIssuePane,
+                  {
+                    controller,
+                    selectedIssue,
+                    onDismissCreate: onDismissIssueCreate
+                  }
+                ) : /* @__PURE__ */ jsx18(IssueManagerShellEmptyState, { controller }) }),
+                /* @__PURE__ */ jsx18(
+                  IssueManagerBottomBar,
+                  {
+                    controller,
+                    isNarrowLayout: shellView.isNarrowLayout,
+                    selectedIssue,
+                    selectedTask,
+                    visible: shellView.content.showBottomBar
+                  }
+                )
+              ] }),
+              shellView.content.isTaskDrawerOpen ? /* @__PURE__ */ jsx18(
+                IssueManagerTaskDrawer,
+                {
+                  controller,
+                  selectedIssue,
+                  selectedTask,
+                  onClose: onCloseTaskDrawer
+                }
+              ) : null
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function IssueManagerShellEmptyState({
+  controller
+}) {
+  return /* @__PURE__ */ jsx18("div", { className: "flex h-full min-h-[320px] items-center justify-center px-10 py-10", children: /* @__PURE__ */ jsxs18("div", { className: "grid max-w-[420px] justify-items-center gap-2 text-center", children: [
+    /* @__PURE__ */ jsx18(IssueManagerEmptyIllustration, {}),
+    /* @__PURE__ */ jsx18("h2", { className: "text-lg font-semibold leading-[1.35] text-[var(--text-primary)]", children: controller.copy.t("messages.noIssues") }),
+    /* @__PURE__ */ jsx18("p", { className: "max-w-[420px] text-base leading-[1.3] text-[var(--text-secondary)]", children: controller.copy.t("emptyState") }),
+    /* @__PURE__ */ jsx18(
+      Button13,
+      {
+        className: "mt-2",
+        type: "button",
+        onClick: () => controller.setIssueEditorMode("create"),
+        children: controller.copy.t("actions.createIssue")
+      }
+    )
+  ] }) });
+}
+
+// src/ui/IssueManagerNode.tsx
+import { jsx as jsx19, jsxs as jsxs19 } from "react/jsx-runtime";
+function IssueManagerNode({
+  feature,
+  nodeId,
+  onStateChange,
+  resolveRichTextAtProviders,
+  service,
+  state,
+  workspaceId
+}) {
+  const { controller, referencePicker, selectedIssue, selectedTask, shell } = useIssueManagerNodeView({
+    feature,
+    nodeId,
+    onStateChange,
+    resolveRichTextAtProviders,
+    service,
+    state,
+    workspaceId
+  });
+  return /* @__PURE__ */ jsxs19(
+    "section",
+    {
+      "aria-label": controller.copy.t("title"),
+      className: "flex h-full min-h-0 w-full min-w-0 flex-col overflow-hidden text-[var(--text-primary)]",
+      "data-issue-manager-node-id": nodeId,
+      "data-issue-manager-workspace-id": workspaceId,
+      children: [
+        /* @__PURE__ */ jsx19(
+          IssueManagerShell,
+          {
+            controller,
+            onCloseTaskDrawer: shell.onCloseTaskDrawer,
+            onDismissIssueCreate: shell.onDismissIssueCreate,
+            selectedIssue,
+            selectedTask
+          }
+        ),
+        /* @__PURE__ */ jsx19(
+          IssueManagerReferencePicker,
+          {
+            copy: controller.copy,
+            fileAdapter: feature.fileAdapter,
+            open: referencePicker.open,
+            workspaceId,
+            onClose: referencePicker.onClose,
+            onConfirm: referencePicker.onConfirm
+          }
+        )
+      ]
+    }
+  );
+}
+function IssueManagerNodeHeader({
+  className,
+  copy,
+  defaultActions,
+  isSidebarAutoCollapsed,
+  isSidebarCollapsed,
+  nodeId,
+  onToggleSidebar,
+  title,
+  ...headerProps
+}) {
+  const { effectiveCollapsed, toggleLabel, toggleSidebar } = useIssueManagerNodeHeaderView({
+    copy,
+    isSidebarAutoCollapsed,
+    isSidebarCollapsed,
+    nodeId,
+    onToggleSidebar
+  });
+  return /* @__PURE__ */ jsxs19(
+    "header",
+    {
+      ...headerProps,
+      className: cn10(
+        "flex h-full min-h-0 items-center justify-between gap-3 bg-[var(--background-panel)] px-2 pl-3",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsxs19("div", { className: "flex min-w-0 items-center gap-2", children: [
+          /* @__PURE__ */ jsx19("span", { className: "min-w-0 truncate text-[13px] font-semibold leading-5 text-[var(--text-primary)]", children: title?.trim() || copy.t("title") }),
+          /* @__PURE__ */ jsx19(
+            Button14,
+            {
+              "aria-label": toggleLabel,
+              className: "rounded-md",
+              "data-issue-manager-sidebar-auto-collapsed": isSidebarAutoCollapsed ? "true" : void 0,
+              "data-issue-manager-sidebar-collapsed": effectiveCollapsed ? "true" : void 0,
+              size: "icon-sm",
+              title: toggleLabel,
+              type: "button",
+              variant: "chrome",
+              onClick: (event) => {
+                event.stopPropagation();
+                toggleSidebar();
+              },
+              onDoubleClick: (event) => event.stopPropagation(),
+              onPointerDown: (event) => event.stopPropagation(),
+              children: /* @__PURE__ */ jsx19(PanelIcon, { className: "size-[18px]" })
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx19(
+          "div",
+          {
+            className: "flex flex-none items-center gap-1",
+            onDoubleClick: (event) => event.stopPropagation(),
+            onPointerDown: (event) => event.stopPropagation(),
+            children: defaultActions
+          }
+        )
+      ]
+    }
+  );
+}
+
+export {
+  dispatchIssueManagerTaskListCollapsed,
+  IssueManagerNode,
+  IssueManagerNodeHeader
+};
+//# sourceMappingURL=chunk-XI6VLBSW.js.map