@tutti-os/agent-gui 0.0.12 → 0.0.13

package/dist/chunk-3YZX5EUC.js

@@ -0,0 +1,1993 @@
+import {
+  Spinner,
+  managedAgentRoundedIconUrl,
+  userAvatarPlaceholderUrl,
+  workspaceAgentActivityStatusLabel
+} from "./chunk-HSXDSFKB.js";
+import {
+  buildAgentGenericMentionHref,
+  buildAgentSessionMentionHref,
+  buildAgentWorkspaceAppMentionHref,
+  buildAgentWorkspaceIssueMentionHref,
+  normalizeAgentSessionMentionTitle
+} from "./chunk-MU2LODEV.js";
+import {
+  AGENT_CONTEXT_MENTION_PROVIDER_IDS
+} from "./chunk-YXSO4ITT.js";
+import {
+  translate
+} from "./chunk-FSTZDNRM.js";
+import {
+  resolveAgentMentionFileThumbnailUrl,
+  resolveAgentMentionFileVisualKind
+} from "./chunk-LUGELG5V.js";
+
+// agent-gui/agentGuiNode/agentMentionAgentGeneratedFilesPresentation.ts
+var AGENT_GENERATED_FOLDER_MIN_FILES = 2;
+function presentAgentGeneratedFileMentionItems(input) {
+  const fileItems = input.files.filter(
+    (item) => item.kind === "file"
+  );
+  if (input.query.trim()) {
+    return fileItems;
+  }
+  if (input.browsePath) {
+    return presentAgentGeneratedBrowseFolder(fileItems, input.browsePath);
+  }
+  return presentAgentGeneratedRootFolders(fileItems);
+}
+function presentAgentGeneratedRootFolders(files) {
+  const filesByDirectory = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const directoryPath = resolveAgentGeneratedFileDirectoryPath(file);
+    const group = filesByDirectory.get(directoryPath);
+    if (group) {
+      group.push(file);
+      continue;
+    }
+    filesByDirectory.set(directoryPath, [file]);
+  }
+  const presented = [];
+  for (const [directoryPath, group] of filesByDirectory) {
+    if (group.length >= AGENT_GENERATED_FOLDER_MIN_FILES) {
+      presented.push(createAgentGeneratedFolderItem(directoryPath, group));
+      continue;
+    }
+    presented.push(...group);
+  }
+  return sortAgentGeneratedMentionItems(presented);
+}
+function presentAgentGeneratedBrowseFolder(files, browsePath) {
+  const normalizedBrowsePath = normalizeAgentGeneratedDirectoryPath(browsePath);
+  const children = files.filter(
+    (file) => resolveAgentGeneratedFileDirectoryPath(file) === normalizedBrowsePath
+  );
+  return [
+    createAgentGeneratedFolderBackItem(normalizedBrowsePath),
+    ...sortAgentGeneratedMentionItems(children)
+  ];
+}
+function createAgentGeneratedFolderItem(directoryPath, files) {
+  const normalizedPath = normalizeAgentGeneratedDirectoryPath(directoryPath);
+  const name = normalizedPath.split("/").filter(Boolean).at(-1) ?? normalizedPath;
+  return {
+    kind: "file",
+    href: `${normalizedPath}/`,
+    path: normalizedPath,
+    name,
+    entryKind: "directory",
+    directoryPath: parentAgentGeneratedDirectoryPath(normalizedPath),
+    mentionNavigation: "agent-generated-folder",
+    childCount: files.length
+  };
+}
+function createAgentGeneratedFolderBackItem(browsePath) {
+  return {
+    kind: "file",
+    href: "",
+    path: browsePath,
+    name: translate("agentHost.agentGui.mentionAgentGeneratedFolderBack"),
+    entryKind: "unknown",
+    directoryPath: parentAgentGeneratedDirectoryPath(browsePath),
+    mentionNavigation: "agent-generated-folder-back"
+  };
+}
+function resolveAgentGeneratedFileDirectoryPath(file) {
+  const directoryPath = file.directoryPath?.trim();
+  if (directoryPath) {
+    return normalizeAgentGeneratedDirectoryPath(directoryPath);
+  }
+  return parentAgentGeneratedDirectoryPath(file.path);
+}
+function parentAgentGeneratedDirectoryPath(path) {
+  const normalized = normalizeAgentGeneratedDirectoryPath(path);
+  const index = normalized.lastIndexOf("/");
+  if (index <= 0) {
+    return "/";
+  }
+  return normalized.slice(0, index);
+}
+function normalizeAgentGeneratedDirectoryPath(path) {
+  return path.trim().replace(/\\/g, "/").replace(/\/+$/, "");
+}
+function sortAgentGeneratedMentionItems(items) {
+  return [...items].sort(
+    (left, right) => left.name.localeCompare(right.name, void 0, { sensitivity: "base" })
+  );
+}
+function agentGeneratedMentionItemKey(item) {
+  if (item.kind !== "file") {
+    return item.targetId;
+  }
+  if (item.mentionNavigation) {
+    return `${item.mentionNavigation}:${item.path}`;
+  }
+  return item.path;
+}
+
+// agent-gui/agentGuiNode/agentMentionSearchDiagnostics.ts
+var AGENT_MENTION_SEARCH_LOG_PREFIX = "[agent-gui] mention-search";
+var {
+  agentGeneratedFile: AGENT_GENERATED_FILE_PROVIDER_ID,
+  agentSession: AGENT_SESSION_PROVIDER_ID,
+  file: FILE_PROVIDER_ID,
+  workspaceApp: WORKSPACE_APP_PROVIDER_ID,
+  workspaceIssue: WORKSPACE_ISSUE_PROVIDER_ID
+} = AGENT_CONTEXT_MENTION_PROVIDER_IDS;
+var AGENT_MENTION_PROVIDER_LOG_ORDER = [
+  FILE_PROVIDER_ID,
+  AGENT_GENERATED_FILE_PROVIDER_ID,
+  WORKSPACE_APP_PROVIDER_ID,
+  WORKSPACE_ISSUE_PROVIDER_ID,
+  AGENT_SESSION_PROVIDER_ID
+];
+function emitAgentMentionSearchDiagnostic(input) {
+  const durationMs = elapsedAgentMentionSearchDiagnosticMs(
+    input.diagnosticNow(),
+    input.startedAt
+  );
+  const providerResults = orderAgentMentionProviderDiagnostics(
+    input.providerDiagnostics
+  );
+  const hasProviderIssue = providerResults.some(
+    (result) => result.status === "timeout" || result.status === "error"
+  );
+  if (input.status === "ready" && !hasProviderIssue && durationMs < input.diagnosticSlowThresholdMs) {
+    return;
+  }
+  const payload = {
+    debounceMs: input.debounceMs,
+    durationMs,
+    ...input.status === "error" ? { errorKind: agentMentionSearchErrorKind(input.error) } : {},
+    event: "agent_gui.mention_search",
+    filter: input.filter,
+    groupCount: input.groups.length,
+    itemCount: input.groups.reduce((sum, group) => sum + group.items.length, 0),
+    mode: input.mode,
+    providerResults,
+    providerTimeoutMs: input.providerTimeoutMs,
+    queryLength: [...input.query].length,
+    requestId: input.requestId,
+    status: input.status,
+    workspaceId: input.workspaceId
+  };
+  try {
+    input.diagnosticInfoLogger(payload);
+  } catch {
+  }
+}
+async function queryAgentMentionProviderWithDiagnostics(input) {
+  if (!input.query) {
+    input.diagnostics.push({
+      durationMs: 0,
+      providerId: input.providerId,
+      resultCount: 0,
+      status: "missing"
+    });
+    return input.fallback;
+  }
+  const startedAt = input.diagnosticNow();
+  try {
+    const { result, timedOut } = await runAgentMentionProviderQuery({
+      fallback: input.fallback,
+      providerTimeoutMs: input.providerTimeoutMs,
+      query: input.query
+    });
+    input.diagnostics.push({
+      durationMs: elapsedAgentMentionSearchDiagnosticMs(
+        input.diagnosticNow(),
+        startedAt
+      ),
+      providerId: input.providerId,
+      resultCount: input.resultCount(result),
+      status: timedOut ? "timeout" : "success"
+    });
+    return result;
+  } catch (error) {
+    input.diagnostics.push({
+      durationMs: elapsedAgentMentionSearchDiagnosticMs(
+        input.diagnosticNow(),
+        startedAt
+      ),
+      errorKind: agentMentionSearchErrorKind(error),
+      providerId: input.providerId,
+      resultCount: 0,
+      status: "error"
+    });
+    throw error;
+  }
+}
+function elapsedAgentMentionSearchDiagnosticMs(now, startedAt) {
+  const durationMs = now - startedAt;
+  if (!Number.isFinite(durationMs)) {
+    return 0;
+  }
+  return Math.max(0, Math.round(durationMs));
+}
+function agentMentionSearchErrorKind(error) {
+  if (error instanceof Error && error.name.trim()) {
+    return error.name.trim();
+  }
+  if (error === null) {
+    return "null";
+  }
+  return typeof error;
+}
+function logAgentMentionSearchInfo(payload) {
+  console.info(AGENT_MENTION_SEARCH_LOG_PREFIX, JSON.stringify(payload));
+}
+function orderAgentMentionProviderDiagnostics(diagnostics) {
+  return [...diagnostics].sort((left, right) => {
+    const leftIndex = providerDiagnosticOrder(left.providerId);
+    const rightIndex = providerDiagnosticOrder(right.providerId);
+    return leftIndex - rightIndex || left.providerId.localeCompare(right.providerId);
+  });
+}
+function providerDiagnosticOrder(providerId) {
+  const index = AGENT_MENTION_PROVIDER_LOG_ORDER.indexOf(providerId);
+  return index === -1 ? AGENT_MENTION_PROVIDER_LOG_ORDER.length : index;
+}
+async function runAgentMentionProviderQuery(input) {
+  const abortController = new AbortController();
+  let timedOut = false;
+  const queryPromise = Promise.resolve().then(
+    () => input.query(abortController.signal)
+  );
+  const queryResultPromise = queryPromise.then(
+    (result) => ({ result, timedOut: false }),
+    (error) => {
+      if (timedOut && abortController.signal.aborted) {
+        return { result: input.fallback, timedOut: true };
+      }
+      throw error;
+    }
+  );
+  if (input.providerTimeoutMs <= 0 || !Number.isFinite(input.providerTimeoutMs)) {
+    return queryResultPromise;
+  }
+  let timeout = null;
+  const timeoutPromise = new Promise(
+    (resolve) => {
+      timeout = setTimeout(() => {
+        timedOut = true;
+        abortController.abort();
+        resolve({ result: input.fallback, timedOut: true });
+      }, input.providerTimeoutMs);
+    }
+  );
+  try {
+    return await Promise.race([queryResultPromise, timeoutPromise]);
+  } finally {
+    if (timeout !== null) {
+      clearTimeout(timeout);
+    }
+  }
+}
+
+// agent-gui/agentGuiNode/AgentMentionLabels.ts
+function agentMentionGroupLabel(groupId) {
+  switch (groupId) {
+    case "apps":
+      return translate("agentHost.agentGui.mentionGroupApps");
+    case "files":
+      return translate("agentHost.agentGui.mentionGroupFiles");
+    case "opened_files":
+      return translate("agentHost.agentGui.mentionGroupOpenedFiles");
+    case "agent_generated_files":
+      return translate("agentHost.agentGui.mentionGroupAgentGeneratedFiles");
+    case "my_sessions":
+      return translate("agentHost.agentGui.mentionGroupMySessions");
+    case "collab_sessions":
+      return translate("agentHost.agentGui.mentionGroupCollabSessions");
+    case "issues":
+      return translate("agentHost.agentGui.mentionGroupIssues");
+  }
+}
+function agentMentionFilterLabel(filter) {
+  switch (filter) {
+    case "all":
+      return translate("agentHost.agentGui.mentionFilterAll");
+    case "app":
+      return translate("agentHost.agentGui.mentionFilterApp");
+    case "file":
+      return translate("agentHost.agentGui.mentionFilterFile");
+    case "session":
+      return translate("agentHost.agentGui.mentionFilterSession");
+    case "issue":
+      return translate("agentHost.agentGui.mentionFilterIssue");
+  }
+}
+function agentMentionEmptyGroupLabel(groupId, query) {
+  if (groupId === "files" || groupId === "opened_files") {
+    return query.trim() ? translate("agentHost.agentGui.mentionNoMatchingFiles") : translate("agentHost.agentGui.mentionEmptyDockFiles");
+  }
+  if (groupId === "agent_generated_files") {
+    return query.trim() ? translate("agentHost.agentGui.mentionNoMatchingFiles") : translate("agentHost.agentGui.mentionEmptyAgentGeneratedFiles");
+  }
+  if (groupId === "apps") {
+    return translate("agentHost.agentGui.mentionEmptyApps");
+  }
+  if (groupId === "my_sessions") {
+    return translate("agentHost.agentGui.mentionEmptyMySessions");
+  }
+  if (groupId === "collab_sessions") {
+    return translate("agentHost.agentGui.mentionEmptyCollabSessions");
+  }
+  return translate("agentHost.agentGui.mentionEmptyIssues");
+}
+
+// agent-gui/agentGuiNode/agentMentionSearchHelpers.ts
+var AGENT_MENTION_FILTER_TAB_ORDER = [
+  "all",
+  "session",
+  "file",
+  "issue",
+  "app"
+];
+var DEFAULT_MENTION_ALL_TAB_PAGE_SIZE = 5;
+var DEFAULT_MENTION_GROUP_PAGE_SIZE = 10;
+function mentionGroupPageSize(filter, _groupId) {
+  return filter === "all" ? DEFAULT_MENTION_ALL_TAB_PAGE_SIZE : DEFAULT_MENTION_GROUP_PAGE_SIZE;
+}
+function mentionGroupExpandCount(group, filter) {
+  const pageSize = mentionGroupPageSize(
+    filter,
+    group.id
+  );
+  const remaining = Math.max(0, group.totalCount - group.visibleCount);
+  return Math.min(pageSize, remaining);
+}
+function groupIdsForFilter(filter) {
+  switch (filter) {
+    case "app":
+      return ["apps"];
+    case "file":
+      return ["opened_files", "agent_generated_files"];
+    case "session":
+      return ["my_sessions"];
+    case "issue":
+      return ["issues"];
+    case "all":
+    default:
+      return ["my_sessions", "files", "issues", "apps"];
+  }
+}
+function shouldShowEmptyGroup(groupId, filter, query) {
+  const hasQuery = query.trim().length > 0;
+  if (groupId === "files") {
+    return filter === "all";
+  }
+  if (groupId === "opened_files" || groupId === "agent_generated_files") {
+    return filter === "file" && !hasQuery;
+  }
+  if (groupId === "apps") {
+    return filter === "all" || filter === "app";
+  }
+  if (groupId === "my_sessions") {
+    return filter === "all" || filter === "session";
+  }
+  if (groupId === "collab_sessions") {
+    return false;
+  }
+  return filter === "all" || filter === "issue";
+}
+function buildEmptyGroup(groupId, query) {
+  return {
+    id: groupId,
+    items: [],
+    totalCount: 0,
+    visibleCount: 0,
+    hasMore: false,
+    emptyLabel: emptyGroupLabel(groupId, query)
+  };
+}
+function emptyGroupLabel(groupId, query) {
+  return agentMentionEmptyGroupLabel(groupId, query);
+}
+function shouldPrefetchBrowseFilter(filter) {
+  return filter === "all" || filter === "app" || filter === "file" || filter === "session" || filter === "issue";
+}
+function filterForGroup(groupId) {
+  switch (groupId) {
+    case "apps":
+      return "app";
+    case "files":
+    case "opened_files":
+    case "agent_generated_files":
+      return "file";
+    case "my_sessions":
+      return "session";
+    case "collab_sessions":
+      return "session";
+    case "issues":
+      return "issue";
+  }
+}
+function resolveMentionGroupItems(groupId, rawGroups) {
+  if (groupId === "files") {
+    return [...rawGroups.opened_files, ...rawGroups.agent_generated_files];
+  }
+  return rawGroups[groupId] ?? [];
+}
+function resolveMentionGroupTotalCount(groupId, totalCounts, itemCount) {
+  if (groupId === "files") {
+    return (totalCounts.opened_files ?? 0) + (totalCounts.agent_generated_files ?? 0);
+  }
+  if (groupId === "agent_generated_files") {
+    return itemCount;
+  }
+  return totalCounts[groupId] ?? itemCount;
+}
+function normalizeQuery(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function compactText(value) {
+  return value?.replace(/\s+/g, " ").trim() ?? "";
+}
+
+// agent-gui/agentGuiNode/AgentMentionSearchController.ts
+var DEFAULT_DEBOUNCE_MS = 120;
+var DEFAULT_FILE_LIMIT = 30;
+var DEFAULT_ISSUE_LIMIT = 25;
+var DEFAULT_SESSION_LIMIT = 30;
+var DEFAULT_PROVIDER_TIMEOUT_MS = 3500;
+var DEFAULT_DIAGNOSTIC_SLOW_THRESHOLD_MS = 250;
+function buildBrowseCategories() {
+  return AGENT_MENTION_FILTER_TAB_ORDER.map((id) => ({
+    id,
+    label: agentMentionFilterLabel(id)
+  }));
+}
+var {
+  agentGeneratedFile: AGENT_GENERATED_FILE_PROVIDER_ID2,
+  agentSession: AGENT_SESSION_PROVIDER_ID2,
+  file: FILE_PROVIDER_ID2,
+  workspaceApp: WORKSPACE_APP_PROVIDER_ID2,
+  workspaceIssue: WORKSPACE_ISSUE_PROVIDER_ID2
+} = AGENT_CONTEXT_MENTION_PROVIDER_IDS;
+var AgentMentionSearchController = class {
+  contextMentionProviders;
+  debounceMs;
+  fileLimit;
+  issueLimit;
+  providerTimeoutMs;
+  diagnosticInfoLogger;
+  diagnosticNow;
+  diagnosticSlowThresholdMs;
+  listeners = /* @__PURE__ */ new Set();
+  expandedCounts = {};
+  totalCounts = {};
+  timer = null;
+  requestId = 0;
+  disposed = false;
+  activeWorkspaceId = "";
+  currentUserId = "";
+  currentFilter = "all";
+  currentQuery = "";
+  currentSessionCwd = "";
+  currentFileSearchLimit;
+  currentIssueSearchLimit;
+  agentGeneratedBrowsePath = null;
+  rawGroups = {
+    apps: [],
+    opened_files: [],
+    agent_generated_files: [],
+    my_sessions: [],
+    collab_sessions: [],
+    issues: []
+  };
+  state = {
+    status: "idle",
+    query: "",
+    mode: "browse",
+    filter: "all",
+    categories: buildBrowseCategories(),
+    groups: [],
+    error: null
+  };
+  constructor(options) {
+    this.contextMentionProviders = new Map(
+      (options.contextMentionProviders ?? []).map((provider) => [
+        provider.id,
+        provider
+      ])
+    );
+    this.debounceMs = options.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.fileLimit = options.fileLimit ?? DEFAULT_FILE_LIMIT;
+    this.issueLimit = options.issueLimit ?? DEFAULT_ISSUE_LIMIT;
+    this.providerTimeoutMs = options.providerTimeoutMs ?? DEFAULT_PROVIDER_TIMEOUT_MS;
+    this.diagnosticInfoLogger = options.diagnosticInfoLogger ?? logAgentMentionSearchInfo;
+    this.diagnosticNow = options.diagnosticNow ?? Date.now;
+    this.diagnosticSlowThresholdMs = options.diagnosticSlowThresholdMs ?? DEFAULT_DIAGNOSTIC_SLOW_THRESHOLD_MS;
+    this.currentFileSearchLimit = this.fileLimit;
+    this.currentIssueSearchLimit = this.issueLimit;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  updateQuery(input) {
+    if (this.disposed) {
+      return;
+    }
+    this.activeWorkspaceId = input.workspaceId.trim();
+    this.currentUserId = input.currentUserId?.trim() ?? "";
+    this.currentSessionCwd = input.sessionCwd?.trim() ?? "";
+    this.currentQuery = normalizeQuery(input.query);
+    this.clearTimer();
+    const requestId = ++this.requestId;
+    this.resetAgentGeneratedBrowsePath();
+    this.resetExpandedCounts();
+    this.resetSearchLimits();
+    if (!this.activeWorkspaceId) {
+      this.setState({
+        status: "idle",
+        query: this.currentQuery,
+        mode: "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: [],
+        error: null
+      });
+      return;
+    }
+    if (!this.currentQuery) {
+      this.startBrowseModeFetch(this.currentFilter);
+      return;
+    }
+    this.setState({
+      status: "loading",
+      query: this.currentQuery,
+      mode: "results",
+      filter: this.currentFilter,
+      categories: buildBrowseCategories(),
+      groups: this.groupsFromRawGroups(),
+      error: null
+    });
+    this.timer = setTimeout(() => {
+      void this.runSearch({
+        workspaceId: this.activeWorkspaceId,
+        currentUserId: this.currentUserId,
+        query: this.currentQuery,
+        requestId
+      });
+    }, this.debounceMs);
+  }
+  setFilter(filter) {
+    if (this.disposed) {
+      return;
+    }
+    this.currentFilter = filter;
+    this.resetAgentGeneratedBrowsePath();
+    this.resetExpandedCounts();
+    if (!this.currentQuery) {
+      this.startBrowseModeFetch(filter);
+      return;
+    }
+    this.setState({
+      status: "ready",
+      query: this.currentQuery,
+      mode: "results",
+      filter: this.currentFilter,
+      categories: buildBrowseCategories(),
+      groups: this.groupsFromRawGroups(),
+      error: null
+    });
+  }
+  enterCategory(category) {
+    if (this.disposed) {
+      return;
+    }
+    this.currentFilter = category;
+    this.resetExpandedCounts();
+    this.clearTimer();
+    if (!this.currentQuery) {
+      this.startBrowseModeFetch(category);
+      return;
+    }
+    if (!this.activeWorkspaceId) {
+      this.emitBrowseState("ready");
+      return;
+    }
+    const requestId = ++this.requestId;
+    this.setState({
+      status: "loading",
+      query: this.currentQuery,
+      mode: "results",
+      filter: this.currentFilter,
+      categories: buildBrowseCategories(),
+      groups: this.groupsFromRawGroups(),
+      error: null
+    });
+    void this.runSearch({
+      workspaceId: this.activeWorkspaceId,
+      currentUserId: this.currentUserId,
+      query: this.currentQuery,
+      requestId
+    });
+  }
+  selectAgentGeneratedMentionItem(item) {
+    if (item.kind !== "file" || !item.mentionNavigation) {
+      return false;
+    }
+    if (item.mentionNavigation === "agent-generated-folder") {
+      this.agentGeneratedBrowsePath = item.path;
+      this.expandedCounts.agent_generated_files = mentionGroupPageSize(
+        this.currentFilter,
+        "agent_generated_files"
+      );
+      this.setState({
+        status: this.state.status === "loading" ? "loading" : "ready",
+        query: this.currentQuery,
+        mode: this.currentQuery ? "results" : "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: this.groupsFromRawGroups(),
+        error: null
+      });
+      return true;
+    }
+    if (item.mentionNavigation === "agent-generated-folder-back") {
+      this.resetAgentGeneratedBrowsePath();
+      this.setState({
+        status: this.state.status === "loading" ? "loading" : "ready",
+        query: this.currentQuery,
+        mode: this.currentQuery ? "results" : "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: this.groupsFromRawGroups(),
+        error: null
+      });
+      return true;
+    }
+    return false;
+  }
+  expandGroup(groupId) {
+    const pageSize = mentionGroupPageSize(this.currentFilter, groupId);
+    const current = this.expandedCounts[groupId] ?? pageSize;
+    this.expandedCounts[groupId] = current + pageSize;
+    if (!this.currentQuery) {
+      const nextFilter = filterForGroup(groupId);
+      if (this.currentFilter === "all") {
+        this.currentFilter = nextFilter;
+      }
+      this.setState({
+        status: "ready",
+        query: "",
+        mode: "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: this.groupsFromRawGroups(),
+        error: null
+      });
+      return;
+    }
+    const needsMoreFiles = (groupId === "opened_files" || groupId === "files" || groupId === "agent_generated_files") && (groupId === "agent_generated_files" ? this.rawGroups.agent_generated_files.length >= this.currentFileSearchLimit : this.rawGroups.opened_files.length >= this.currentFileSearchLimit);
+    const needsMoreIssues = groupId === "issues" && (this.totalCounts.issues ?? this.rawGroups.issues.length) > this.rawGroups.issues.length;
+    if (needsMoreFiles) {
+      this.currentFileSearchLimit += DEFAULT_MENTION_GROUP_PAGE_SIZE;
+    }
+    if (needsMoreIssues) {
+      this.currentIssueSearchLimit += DEFAULT_MENTION_GROUP_PAGE_SIZE;
+    }
+    if (needsMoreFiles || needsMoreIssues) {
+      this.clearTimer();
+      const requestId = ++this.requestId;
+      this.setState({
+        status: "loading",
+        query: this.currentQuery,
+        mode: "results",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: this.groupsFromRawGroups(),
+        error: null
+      });
+      void this.runSearch({
+        workspaceId: this.activeWorkspaceId,
+        currentUserId: this.currentUserId,
+        query: this.currentQuery,
+        requestId
+      });
+      return;
+    }
+    this.setState({
+      status: "ready",
+      query: this.currentQuery,
+      mode: "results",
+      filter: this.currentFilter,
+      categories: buildBrowseCategories(),
+      groups: this.groupsFromRawGroups(),
+      error: null
+    });
+  }
+  close() {
+    this.clearTimer();
+    this.requestId += 1;
+    this.currentFilter = "all";
+    this.resetAgentGeneratedBrowsePath();
+    this.resetExpandedCounts();
+    this.resetSearchLimits();
+    this.rawGroups = {
+      apps: [],
+      opened_files: [],
+      agent_generated_files: [],
+      my_sessions: [],
+      collab_sessions: [],
+      issues: []
+    };
+    this.totalCounts.apps = 0;
+    this.totalCounts.opened_files = 0;
+    this.totalCounts.agent_generated_files = 0;
+    this.totalCounts.my_sessions = 0;
+    this.totalCounts.collab_sessions = 0;
+    this.totalCounts.issues = 0;
+    this.currentQuery = "";
+    this.setState({
+      status: "idle",
+      query: "",
+      mode: "browse",
+      filter: "all",
+      categories: buildBrowseCategories(),
+      groups: [],
+      error: null
+    });
+  }
+  dispose() {
+    this.disposed = true;
+    this.clearTimer();
+    this.listeners.clear();
+    this.requestId += 1;
+  }
+  startBrowseModeFetch(filter) {
+    if (!this.activeWorkspaceId || !shouldPrefetchBrowseFilter(filter)) {
+      this.rawGroups = {
+        apps: [],
+        opened_files: [],
+        agent_generated_files: [],
+        my_sessions: [],
+        collab_sessions: [],
+        issues: []
+      };
+      this.emitBrowseState("ready");
+      return;
+    }
+    this.clearTimer();
+    const requestId = ++this.requestId;
+    this.rawGroups = {
+      apps: [],
+      opened_files: [],
+      agent_generated_files: [],
+      my_sessions: [],
+      collab_sessions: [],
+      issues: []
+    };
+    this.emitBrowseState("loading");
+    void this.runBrowseSearch({
+      workspaceId: this.activeWorkspaceId,
+      currentUserId: this.currentUserId,
+      requestId,
+      filter
+    });
+  }
+  async runSearch(input) {
+    const startedAt = this.diagnosticNow();
+    const providerDiagnostics = [];
+    try {
+      const [fileItems, appItems, issueItems, sessionItems] = await Promise.all(
+        [
+          this.queryProviderMentionItemsById({
+            providerId: FILE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: input.query,
+            limit: this.currentFileSearchLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: WORKSPACE_APP_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: input.query,
+            limit: DEFAULT_MENTION_GROUP_PAGE_SIZE,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: WORKSPACE_ISSUE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: input.query,
+            limit: this.currentIssueSearchLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: AGENT_SESSION_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: input.query,
+            limit: DEFAULT_SESSION_LIMIT,
+            diagnostics: providerDiagnostics
+          })
+        ]
+      );
+      if (!this.canApply(input.requestId, input.workspaceId, input.query)) {
+        return;
+      }
+      this.rawGroups = {
+        apps: appItems.filter((item) => item.kind === "workspace-app"),
+        opened_files: fileItems.filter((item) => item.kind === "file"),
+        agent_generated_files: [],
+        my_sessions: sessionItems.filter(
+          (item) => item.kind === "session" && item.scope === "my_sessions"
+        ),
+        collab_sessions: sessionItems.filter(
+          (item) => item.kind === "session" && item.scope === "collab_sessions"
+        ),
+        issues: issueItems.filter((item) => item.kind === "workspace-issue")
+      };
+      this.totalCounts.apps = this.rawGroups.apps.length;
+      this.totalCounts.opened_files = this.rawGroups.opened_files.length;
+      this.totalCounts.agent_generated_files = 0;
+      this.totalCounts.my_sessions = this.rawGroups.my_sessions.length;
+      this.totalCounts.collab_sessions = this.rawGroups.collab_sessions.length;
+      this.totalCounts.issues = this.rawGroups.issues.length;
+      const groups = this.groupsFromRawGroups();
+      this.setState({
+        status: "ready",
+        query: input.query,
+        mode: "results",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups,
+        error: null
+      });
+      this.logSearchDiagnostic({
+        filter: this.currentFilter,
+        groups,
+        mode: "results",
+        providerDiagnostics,
+        query: input.query,
+        requestId: input.requestId,
+        startedAt,
+        status: "ready",
+        workspaceId: input.workspaceId
+      });
+    } catch (error) {
+      if (!this.canApply(input.requestId, input.workspaceId, input.query)) {
+        return;
+      }
+      this.setState({
+        status: "error",
+        query: input.query,
+        mode: "results",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: [],
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.logSearchDiagnostic({
+        error,
+        filter: this.currentFilter,
+        groups: [],
+        mode: "results",
+        providerDiagnostics,
+        query: input.query,
+        requestId: input.requestId,
+        startedAt,
+        status: "error",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  async runBrowseSearch(input) {
+    const startedAt = this.diagnosticNow();
+    const providerDiagnostics = [];
+    try {
+      if (input.filter === "file") {
+        const [fileItems, agentGeneratedFileItems] = await Promise.all([
+          this.queryProviderMentionItemsById({
+            providerId: FILE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: this.fileLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: AGENT_GENERATED_FILE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: this.fileLimit,
+            diagnostics: providerDiagnostics
+          })
+        ]);
+        if (!this.canApply(input.requestId, input.workspaceId, "")) {
+          return;
+        }
+        this.rawGroups = {
+          apps: [],
+          opened_files: fileItems.filter((item) => item.kind === "file"),
+          agent_generated_files: agentGeneratedFileItems.filter(
+            (item) => item.kind === "file"
+          ),
+          my_sessions: [],
+          collab_sessions: [],
+          issues: []
+        };
+        this.totalCounts.apps = 0;
+        this.totalCounts.opened_files = this.rawGroups.opened_files.length;
+        this.totalCounts.agent_generated_files = this.rawGroups.agent_generated_files.length;
+        this.totalCounts.my_sessions = 0;
+        this.totalCounts.collab_sessions = 0;
+        this.totalCounts.issues = 0;
+      } else if (input.filter === "app") {
+        const appItems = await this.queryProviderMentionItemsById({
+          providerId: WORKSPACE_APP_PROVIDER_ID2,
+          workspaceId: input.workspaceId,
+          currentUserId: input.currentUserId,
+          query: "",
+          limit: DEFAULT_MENTION_GROUP_PAGE_SIZE,
+          diagnostics: providerDiagnostics
+        });
+        if (!this.canApply(input.requestId, input.workspaceId, "")) {
+          return;
+        }
+        this.rawGroups = {
+          apps: appItems.filter((item) => item.kind === "workspace-app"),
+          opened_files: [],
+          agent_generated_files: [],
+          my_sessions: [],
+          collab_sessions: [],
+          issues: []
+        };
+        this.totalCounts.apps = this.rawGroups.apps.length;
+        this.totalCounts.opened_files = 0;
+        this.totalCounts.agent_generated_files = 0;
+        this.totalCounts.my_sessions = 0;
+        this.totalCounts.collab_sessions = 0;
+        this.totalCounts.issues = 0;
+      } else if (input.filter === "issue") {
+        const issueItems = await this.queryProviderMentionItemsById({
+          providerId: WORKSPACE_ISSUE_PROVIDER_ID2,
+          workspaceId: input.workspaceId,
+          currentUserId: input.currentUserId,
+          query: "",
+          limit: this.currentIssueSearchLimit,
+          diagnostics: providerDiagnostics
+        });
+        if (!this.canApply(input.requestId, input.workspaceId, "")) {
+          return;
+        }
+        this.rawGroups = {
+          apps: [],
+          opened_files: [],
+          agent_generated_files: [],
+          my_sessions: [],
+          collab_sessions: [],
+          issues: issueItems.filter((item) => item.kind === "workspace-issue")
+        };
+        this.totalCounts.apps = 0;
+        this.totalCounts.opened_files = 0;
+        this.totalCounts.agent_generated_files = 0;
+        this.totalCounts.my_sessions = 0;
+        this.totalCounts.collab_sessions = 0;
+        this.totalCounts.issues = this.rawGroups.issues.length;
+      } else if (input.filter === "session") {
+        const sessionItems = await this.queryProviderMentionItemsById({
+          providerId: AGENT_SESSION_PROVIDER_ID2,
+          workspaceId: input.workspaceId,
+          currentUserId: input.currentUserId,
+          query: "",
+          limit: DEFAULT_SESSION_LIMIT,
+          diagnostics: providerDiagnostics
+        });
+        if (!this.canApply(input.requestId, input.workspaceId, "")) {
+          return;
+        }
+        const sessionMentionItems = sessionItems.filter(
+          (item) => item.kind === "session"
+        );
+        const mySessionItems = sessionMentionItems.filter(
+          (item) => input.currentUserId ? item.scope === "my_sessions" : true
+        ).map(
+          (item) => item.scope === "my_sessions" ? item : { ...item, scope: "my_sessions" }
+        );
+        this.rawGroups = {
+          apps: [],
+          opened_files: [],
+          agent_generated_files: [],
+          my_sessions: mySessionItems,
+          collab_sessions: [],
+          issues: []
+        };
+        this.totalCounts.apps = 0;
+        this.totalCounts.opened_files = 0;
+        this.totalCounts.agent_generated_files = 0;
+        this.totalCounts.my_sessions = this.rawGroups.my_sessions.length;
+        this.totalCounts.collab_sessions = this.rawGroups.collab_sessions.length;
+        this.totalCounts.issues = 0;
+      } else {
+        const [
+          appItems,
+          fileItems,
+          agentGeneratedFileItems,
+          issueItems,
+          sessionItems
+        ] = await Promise.all([
+          this.queryProviderMentionItemsById({
+            providerId: WORKSPACE_APP_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: DEFAULT_MENTION_GROUP_PAGE_SIZE,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: FILE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: this.fileLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: AGENT_GENERATED_FILE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: this.fileLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: WORKSPACE_ISSUE_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: this.currentIssueSearchLimit,
+            diagnostics: providerDiagnostics
+          }),
+          this.queryProviderMentionItemsById({
+            providerId: AGENT_SESSION_PROVIDER_ID2,
+            workspaceId: input.workspaceId,
+            currentUserId: input.currentUserId,
+            query: "",
+            limit: DEFAULT_SESSION_LIMIT,
+            diagnostics: providerDiagnostics
+          })
+        ]);
+        if (!this.canApply(input.requestId, input.workspaceId, "")) {
+          return;
+        }
+        this.rawGroups = {
+          apps: appItems.filter((item) => item.kind === "workspace-app"),
+          opened_files: fileItems.filter((item) => item.kind === "file"),
+          agent_generated_files: agentGeneratedFileItems.filter(
+            (item) => item.kind === "file"
+          ),
+          my_sessions: sessionItems.filter(
+            (item) => item.kind === "session" && item.scope === "my_sessions"
+          ),
+          collab_sessions: sessionItems.filter(
+            (item) => item.kind === "session" && item.scope === "collab_sessions"
+          ),
+          issues: issueItems.filter((item) => item.kind === "workspace-issue")
+        };
+        this.totalCounts.apps = this.rawGroups.apps.length;
+        this.totalCounts.opened_files = this.rawGroups.opened_files.length;
+        this.totalCounts.agent_generated_files = this.rawGroups.agent_generated_files.length;
+        this.totalCounts.my_sessions = this.rawGroups.my_sessions.length;
+        this.totalCounts.collab_sessions = this.rawGroups.collab_sessions.length;
+        this.totalCounts.issues = this.rawGroups.issues.length;
+      }
+      const groups = this.groupsFromRawGroups();
+      this.setState({
+        status: "ready",
+        query: "",
+        mode: "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups,
+        error: null
+      });
+      this.logSearchDiagnostic({
+        filter: this.currentFilter,
+        groups,
+        mode: "browse",
+        providerDiagnostics,
+        query: "",
+        requestId: input.requestId,
+        startedAt,
+        status: "ready",
+        workspaceId: input.workspaceId
+      });
+    } catch (error) {
+      if (!this.canApply(input.requestId, input.workspaceId, "")) {
+        return;
+      }
+      this.setState({
+        status: "error",
+        query: "",
+        mode: "browse",
+        filter: this.currentFilter,
+        categories: buildBrowseCategories(),
+        groups: [],
+        error: error instanceof Error ? error.message : String(error)
+      });
+      this.logSearchDiagnostic({
+        error,
+        filter: this.currentFilter,
+        groups: [],
+        mode: "browse",
+        providerDiagnostics,
+        query: "",
+        requestId: input.requestId,
+        startedAt,
+        status: "error",
+        workspaceId: input.workspaceId
+      });
+    }
+  }
+  async queryProviderMentionItems(input) {
+    const items = await input.provider.query({
+      keyword: input.query,
+      maxResults: input.limit,
+      abortSignal: input.abortSignal,
+      trigger: "@",
+      context: {
+        metadata: {
+          currentUserId: input.currentUserId,
+          sessionCwd: this.currentSessionCwd || void 0,
+          target: "agent-gui",
+          workspaceId: input.workspaceId
+        }
+      }
+    });
+    if (input.abortSignal.aborted) {
+      return [];
+    }
+    const mentionItems = await Promise.all(
+      items.map(async (item) => {
+        const mentionItem = providerItemToAgentMentionItem({
+          currentUserId: input.currentUserId,
+          insertResult: input.provider.toInsertResult(item),
+          label: input.provider.getItemLabel(item),
+          providerId: input.provider.id,
+          subtitle: input.provider.getItemSubtitle?.(item) ?? "",
+          workspaceId: input.workspaceId
+        });
+        if (!mentionItem || mentionItem.kind !== "file") {
+          return mentionItem;
+        }
+        const thumbnailUrl = await Promise.resolve(
+          input.provider.getItemThumbnailUrl?.(item) ?? null
+        ).catch(() => null);
+        const resolvedThumbnailUrl = resolveAgentMentionFileThumbnailUrl({
+          ...mentionItem,
+          thumbnailUrl
+        });
+        if (!resolvedThumbnailUrl) {
+          return mentionItem;
+        }
+        return {
+          ...mentionItem,
+          thumbnailUrl: resolvedThumbnailUrl
+        };
+      })
+    );
+    return mentionItems.filter(
+      (item) => item !== null
+    );
+  }
+  async queryProviderMentionItemsById(input) {
+    const provider = this.contextMentionProviders.get(input.providerId);
+    return queryAgentMentionProviderWithDiagnostics({
+      diagnosticNow: this.diagnosticNow,
+      diagnostics: input.diagnostics,
+      fallback: [],
+      providerId: input.providerId,
+      providerTimeoutMs: this.providerTimeoutMs,
+      query: provider ? (abortSignal) => this.queryProviderMentionItems({
+        provider,
+        workspaceId: input.workspaceId,
+        currentUserId: input.currentUserId,
+        query: input.query,
+        limit: input.limit,
+        abortSignal
+      }) : null,
+      resultCount: (result) => result.length
+    });
+  }
+  logSearchDiagnostic(input) {
+    emitAgentMentionSearchDiagnostic({
+      debounceMs: this.debounceMs,
+      diagnosticInfoLogger: this.diagnosticInfoLogger,
+      diagnosticNow: this.diagnosticNow,
+      diagnosticSlowThresholdMs: this.diagnosticSlowThresholdMs,
+      error: input.error,
+      filter: input.filter,
+      groups: input.groups,
+      mode: input.mode,
+      providerDiagnostics: input.providerDiagnostics,
+      providerTimeoutMs: this.providerTimeoutMs,
+      query: input.query,
+      requestId: input.requestId,
+      startedAt: input.startedAt,
+      status: input.status,
+      workspaceId: input.workspaceId
+    });
+  }
+  groupsFromRawGroups() {
+    const orderedGroupIds = groupIdsForFilter(this.currentFilter);
+    const groups = orderedGroupIds.map((groupId) => {
+      const rawItems = resolveMentionGroupItems(groupId, this.rawGroups);
+      const items = groupId === "agent_generated_files" ? presentAgentGeneratedFileMentionItems({
+        files: rawItems,
+        browsePath: this.agentGeneratedBrowsePath,
+        query: this.currentQuery
+      }) : rawItems;
+      if (items.length === 0) {
+        if (!shouldShowEmptyGroup(
+          groupId,
+          this.currentFilter,
+          this.currentQuery
+        )) {
+          return null;
+        }
+        return buildEmptyGroup(groupId, this.currentQuery);
+      }
+      const pageSize = mentionGroupPageSize(this.currentFilter, groupId);
+      const visibleCount = Math.min(
+        items.length,
+        this.expandedCounts[groupId] ?? pageSize
+      );
+      const totalCount = resolveMentionGroupTotalCount(
+        groupId,
+        this.totalCounts,
+        items.length
+      );
+      return {
+        id: groupId,
+        items: items.slice(0, visibleCount),
+        totalCount,
+        visibleCount,
+        hasMore: items.length > visibleCount || (groupId === "opened_files" || groupId === "files" || groupId === "agent_generated_files") && items.length >= this.currentFileSearchLimit || totalCount > visibleCount
+      };
+    }).filter((group) => group !== null);
+    return orderMentionGroupsForFilter({
+      filter: this.currentFilter,
+      groups,
+      query: this.currentQuery
+    });
+  }
+  emitBrowseState(status) {
+    this.setState({
+      status,
+      query: "",
+      mode: "browse",
+      filter: this.currentFilter,
+      categories: buildBrowseCategories(),
+      groups: [],
+      error: null
+    });
+  }
+  canApply(requestId, workspaceId, query) {
+    return !this.disposed && requestId === this.requestId && workspaceId === this.activeWorkspaceId && query === this.currentQuery;
+  }
+  clearTimer() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  resetExpandedCounts() {
+    for (const groupId of [
+      "files",
+      "opened_files",
+      "agent_generated_files",
+      "my_sessions",
+      "collab_sessions",
+      "apps",
+      "issues"
+    ]) {
+      this.expandedCounts[groupId] = mentionGroupPageSize(
+        this.currentFilter,
+        groupId
+      );
+    }
+  }
+  resetSearchLimits() {
+    this.currentFileSearchLimit = this.fileLimit;
+    this.currentIssueSearchLimit = this.issueLimit;
+  }
+  resetAgentGeneratedBrowsePath() {
+    this.agentGeneratedBrowsePath = null;
+  }
+  setState(state) {
+    this.state = state;
+    for (const listener of this.listeners) {
+      listener(state);
+    }
+  }
+};
+function orderMentionGroupsForFilter(input) {
+  if (input.filter !== "all") {
+    return input.groups;
+  }
+  const query = normalizeQuery(input.query).toLowerCase();
+  return input.groups.map((group, index) => ({
+    group,
+    hasItems: group.items.length > 0,
+    index,
+    score: mentionGroupBestMatchScore(group, query)
+  })).sort((left, right) => {
+    if (left.hasItems !== right.hasItems) {
+      return left.hasItems ? -1 : 1;
+    }
+    if (query && left.score !== right.score) {
+      return right.score - left.score;
+    }
+    return left.index - right.index;
+  }).map((entry) => entry.group);
+}
+function mentionGroupBestMatchScore(group, query) {
+  if (!query) {
+    return 0;
+  }
+  return group.items.reduce(
+    (bestScore, item) => Math.max(bestScore, mentionItemMatchScore(item, query)),
+    0
+  );
+}
+function mentionItemMatchScore(item, query) {
+  const primary = [];
+  const secondary = [];
+  let kindBoost = 0;
+  if (item.kind === "workspace-app") {
+    kindBoost = 8;
+    primary.push(item.name, item.appId, item.targetId);
+    secondary.push(item.description ?? "");
+  } else if (item.kind === "file") {
+    primary.push(item.name);
+    secondary.push(item.path, item.directoryPath);
+  } else if (item.kind === "session") {
+    primary.push(item.title);
+    secondary.push(
+      item.name,
+      item.initiatorName,
+      item.agentName,
+      item.inputPreview ?? "",
+      item.summaryPreview ?? ""
+    );
+  } else if (item.kind === "workspace-issue") {
+    primary.push(item.title, item.name);
+    secondary.push(
+      item.creatorName ?? "",
+      item.status ?? "",
+      item.contentPreview ?? ""
+    );
+  } else if (item.kind === "workspace-app-factory") {
+    primary.push(item.name, item.jobId, item.targetId);
+    secondary.push(item.action ?? "", item.contextPath ?? "");
+  }
+  const primaryScore = maxTextMatchScore(primary, query, {
+    contains: 60,
+    exact: 100,
+    prefix: 90,
+    wordPrefix: 80
+  });
+  const secondaryScore = maxTextMatchScore(secondary, query, {
+    contains: 25,
+    exact: 60,
+    prefix: 50,
+    wordPrefix: 40
+  });
+  const score = Math.max(primaryScore, secondaryScore);
+  return score > 0 ? score + kindBoost : 0;
+}
+function maxTextMatchScore(values, query, scores) {
+  return values.reduce(
+    (bestScore, value) => Math.max(bestScore, textMatchScore(value, query, scores)),
+    0
+  );
+}
+function textMatchScore(value, query, scores) {
+  const normalized = normalizeQuery(value).toLowerCase();
+  if (!normalized) {
+    return 0;
+  }
+  if (normalized === query) {
+    return scores.exact;
+  }
+  if (normalized.startsWith(query)) {
+    return scores.prefix;
+  }
+  if (normalized.split(/[^a-z0-9]+/i).some((word) => word.startsWith(query))) {
+    return scores.wordPrefix;
+  }
+  return normalized.includes(query) ? scores.contains : 0;
+}
+function providerItemToAgentMentionItem(input) {
+  const label = compactText(input.label);
+  if (!label) {
+    return null;
+  }
+  if (input.insertResult.kind === "markdown-link") {
+    const href = input.insertResult.href.trim();
+    return {
+      kind: "file",
+      href,
+      path: href,
+      name: label,
+      entryKind: href.endsWith("/") ? "directory" : "unknown",
+      directoryPath: dirnameFromProviderWorkspaceFileHref(href)
+    };
+  }
+  if (input.insertResult.kind !== "mention") {
+    return null;
+  }
+  const mention = input.insertResult.mention;
+  const targetId = mention.entityId.trim();
+  if (!targetId) {
+    return null;
+  }
+  const scope = normalizeMentionScope(mention.scope);
+  const presentation = mention.presentation ?? {};
+  const workspaceId = scope.workspaceId || input.workspaceId;
+  if (input.providerId === FILE_PROVIDER_ID2 || input.providerId === AGENT_GENERATED_FILE_PROVIDER_ID2) {
+    return {
+      kind: "file",
+      href: buildAgentGenericMentionHref(input.providerId, targetId, scope),
+      path: targetId,
+      name: label,
+      entryKind: targetId.endsWith("/") ? "directory" : "unknown",
+      directoryPath: dirnameFromProviderWorkspaceFileHref(targetId),
+      thumbnailUrl: presentation.thumbnailUrl?.trim() || void 0
+    };
+  }
+  if (input.providerId === WORKSPACE_ISSUE_PROVIDER_ID2) {
+    return {
+      kind: "workspace-issue",
+      href: buildAgentWorkspaceIssueMentionHref(workspaceId, targetId, {
+        topicId: scope.topicId
+      }),
+      workspaceId,
+      targetId,
+      topicId: scope.topicId,
+      name: label,
+      title: label,
+      status: presentation.status?.trim() || void 0,
+      contentPreview: compactText(presentation.description) || compactText(input.subtitle) || void 0
+    };
+  }
+  if (input.providerId === WORKSPACE_APP_PROVIDER_ID2) {
+    const appId = targetId;
+    return {
+      kind: "workspace-app",
+      href: buildAgentWorkspaceAppMentionHref(workspaceId, appId),
+      workspaceId,
+      targetId: appId,
+      appId,
+      name: label,
+      description: compactText(presentation.description) || compactText(presentation.subtitle) || compactText(input.subtitle) || void 0,
+      iconUrl: presentation.iconUrl?.trim() || void 0
+    };
+  }
+  if (input.providerId === AGENT_SESSION_PROVIDER_ID2) {
+    const agentName = presentation.subtitle?.trim() || "";
+    const title = normalizeAgentSessionMentionTitle(label) || label;
+    const description = compactText(presentation.description);
+    const summaryPreview = description || compactText(input.subtitle) || void 0;
+    return {
+      kind: "session",
+      href: buildAgentSessionMentionHref(workspaceId, targetId),
+      workspaceId,
+      targetId,
+      name: label,
+      title,
+      scope: mentionSessionScope({
+        currentUserId: input.currentUserId,
+        rawScope: scope.scope,
+        userId: scope.userId
+      }),
+      initiatorName: "",
+      agentName,
+      status: presentation.status?.trim() || void 0,
+      inputPreview: description || void 0,
+      summaryPreview
+    };
+  }
+  return null;
+}
+function normalizeMentionScope(scope) {
+  return Object.fromEntries(
+    Object.entries(scope ?? {}).map(([key, value]) => [key.trim(), value.trim()]).filter(([key, value]) => key.length > 0 && value.length > 0)
+  );
+}
+function mentionSessionScope(input) {
+  const rawScope = input.rawScope?.trim() ?? "";
+  if (rawScope === "my_sessions" || rawScope === "collab_sessions") {
+    return rawScope;
+  }
+  return input.userId && input.userId === input.currentUserId ? "my_sessions" : "collab_sessions";
+}
+function dirnameFromProviderWorkspaceFileHref(href) {
+  const normalized = href.replace(/\/+$/, "");
+  const index = normalized.lastIndexOf("/");
+  if (index <= 0) {
+    return "/";
+  }
+  return normalized.slice(0, index);
+}
+
+// agent-gui/agentGuiNode/AgentFileMentionPalette.tsx
+import {
+  normalizeAgentActivityDisplayStatus
+} from "@tutti-os/agent-activity-core";
+import {
+  MentionPalette,
+  flattenMentionPaletteEntries,
+  issueMentionStatusTone,
+  renderMentionRow
+} from "@tutti-os/ui-rich-text/at-panel";
+
+// shared/roomIssueStatusLabel.ts
+function roomIssueStatusLabel(status, t) {
+  const translateFn = t ?? translate;
+  switch (status) {
+    case "not_started":
+      return translateFn("agentHost.roomIssueNode.issueStatusNotStarted");
+    case "running":
+      return translateFn("agentHost.roomIssueNode.issueStatusRunning");
+    case "in_progress":
+      return translateFn("agentHost.roomIssueNode.issueStatusInProgress");
+    case "pending_acceptance":
+      return translateFn(
+        "agentHost.roomIssueNode.issueStatusPendingAcceptance"
+      );
+    case "completed":
+      return translateFn("agentHost.roomIssueNode.issueStatusCompleted");
+    case "failed":
+      return translateFn("agentHost.roomIssueNode.issueStatusFailed");
+    case "canceled":
+      return translateFn("agentHost.roomIssueNode.issueStatusCanceled");
+    default:
+      return status || translateFn("agentHost.roomIssueNode.issueStatusUnknown");
+  }
+}
+
+// agent-gui/agentGuiNode/AgentFileMentionPalette.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var AGENT_MENTION_PALETTE_THEME = {
+  classNames: {
+    palette: "agent-gui-node__mention-palette",
+    header: "agent-gui-node__mention-palette-header",
+    footer: "agent-gui-node__mention-palette-footer",
+    tabs: "agent-gui-node__mention-palette-tabs",
+    scrollRegion: "agent-gui-node__mention-palette-scroll-region",
+    scrollbar: "workspace-agents-status-panel__scrollbar agent-gui-node__mention-palette-scrollbar",
+    scrollbarThumb: "workspace-agents-status-panel__scrollbar-thumb",
+    hint: "agent-gui-node__mention-palette-hint",
+    hintItem: "agent-gui-node__mention-palette-hint-item",
+    hintButton: "agent-gui-node__mention-palette-hint-button",
+    hintSeparator: "agent-gui-node__mention-palette-hint-separator",
+    shortcut: "agent-gui-node__mention-palette-shortcut",
+    shortcutArrow: "agent-gui-node__mention-palette-shortcut--arrow",
+    shortcutButton: "agent-gui-node__mention-palette-shortcut-button",
+    shortcutGroup: "agent-gui-node__mention-palette-shortcut-group"
+  },
+  testIds: {
+    emptyState: "agent-gui-mention-palette-empty-state",
+    hint: "agent-gui-mention-palette-hint",
+    scrollbar: "agent-gui-mention-palette-scrollbar",
+    loadingSpinner: "agent-mention-loading-spinner"
+  },
+  groupDividerAttribute: "data-agent-mention-group-divider"
+};
+var AGENT_MENTION_ROW_CLASS_NAMES = {
+  fileIcon: "agent-gui-node__mention-file-icon",
+  fileThumb: "agent-gui-node__mention-file-thumb",
+  kindIcon: "tsh-agent-object-token__kind-icon",
+  avatarImgUserPlaceholder: "workspace-agents-status-panel__avatar-img--user-placeholder"
+};
+function agentMentionItemKey(item) {
+  return `${item.kind}:${item.kind === "file" ? agentGeneratedMentionItemKey(item) : item.targetId}`;
+}
+function flattenAgentMentionPaletteEntries(state) {
+  return flattenMentionPaletteEntries(
+    state,
+    (item) => agentMentionItemKey(item)
+  ).map((entry) => {
+    if (entry.type === "item") {
+      const item = entry.groupId !== void 0 && entry.itemIndex !== void 0 ? state.groups.find((group) => group.id === entry.groupId)?.items[entry.itemIndex] : void 0;
+      return {
+        key: entry.key,
+        type: "item",
+        groupId: entry.groupId,
+        item
+      };
+    }
+    return {
+      key: entry.key,
+      type: entry.type,
+      categoryId: entry.categoryId,
+      groupId: entry.groupId
+    };
+  });
+}
+function groupStartKeys(state) {
+  if (state.mode === "browse") {
+    return state.categories.map((category) => `category:${category.id}`);
+  }
+  return state.groups.map((group) => {
+    const firstItem = group.items[0];
+    if (firstItem) {
+      return `${group.id}:${firstItem.kind}:${firstItem.kind === "file" ? firstItem.path : firstItem.targetId}`;
+    }
+    if (group.hasMore) {
+      return `expand:${group.id}`;
+    }
+    return null;
+  }).filter((key) => key !== null);
+}
+function AgentFileMentionPalette({
+  state,
+  highlightedKey,
+  label,
+  loadingLabel,
+  emptyLabel,
+  errorLabel,
+  tabHintLabel,
+  maxHeightPx,
+  shouldCenterHighlightedItem = false,
+  onHighlightChange,
+  onSelectItem,
+  onSelectCategory,
+  onSelectFilter,
+  onExpandGroup,
+  onCycleFilter,
+  onMoveSelection
+}) {
+  "use memo";
+  const filter = state.filter;
+  const highlightedBrowseCategory = highlightedKey?.startsWith("category:") ? highlightedKey.slice("category:".length) : null;
+  const browseDisplayFilter = isBrowseCategoryId(highlightedBrowseCategory) ? highlightedBrowseCategory : filter;
+  const showBrowseHint = shouldShowBrowseSearchHint({
+    browseFilter: filter,
+    groups: state.groups,
+    highlightedBrowseCategory,
+    mode: state.mode
+  });
+  const categories = state.mode === "browse" ? state.categories : AGENT_MENTION_FILTER_TAB_ORDER.map((id) => ({
+    id,
+    label: agentMentionFilterLabel(id)
+  }));
+  const shellState = showBrowseHint ? { ...state, categories, groups: [] } : {
+    ...state,
+    categories,
+    groups: state.groups.map(
+      (group, index) => decorateMentionGroup(
+        group,
+        index,
+        state.groups,
+        filter,
+        state.query
+      )
+    )
+  };
+  const emptyLabelForShell = showBrowseHint ? browseHintForFilter(browseDisplayFilter) : resolveMentionPaletteEmptyLabel({
+    emptyLabel,
+    filter,
+    mode: state.mode,
+    query: state.query
+  });
+  const showFileSearchMoreHint = shouldShowFileSearchMoreHint({
+    filter,
+    groups: state.groups,
+    mode: state.mode,
+    query: state.query
+  });
+  return /* @__PURE__ */ jsx(
+    MentionPalette,
+    {
+      state: shellState,
+      highlightedKey,
+      getItemKey: agentMentionItemKey,
+      renderItem: (item) => renderMentionRow(agentMentionItemToRowItem(item), {
+        classNames: AGENT_MENTION_ROW_CLASS_NAMES,
+        dataAttributeMode: "agent"
+      }),
+      labels: {
+        loading: loadingLabel,
+        empty: emptyLabelForShell,
+        error: errorLabel,
+        tabHint: tabHintLabel,
+        listbox: label
+      },
+      hintLabels: {
+        cycleFilter: translate("agentHost.agentGui.fileMentionSwitchCategory"),
+        moveSelection: translate(
+          "agentHost.agentGui.fileMentionSwitchSelection"
+        )
+      },
+      maxHeightPx,
+      scrollHighlightedIntoViewCentered: shouldCenterHighlightedItem,
+      loadingBanner: /* @__PURE__ */ jsx(MentionPaletteLoadingBanner, { label: loadingLabel }),
+      theme: AGENT_MENTION_PALETTE_THEME,
+      renderListFooter: showFileSearchMoreHint ? () => /* @__PURE__ */ jsx(MentionFileSearchMoreHint, {}) : void 0,
+      onHighlightChange,
+      onSelectItem: (item) => onSelectItem(item),
+      onSelectCategory: (categoryId) => onSelectCategory(categoryId),
+      onSelectFilter: (nextFilter) => onSelectFilter(nextFilter),
+      onExpandGroup: (groupId) => onExpandGroup(groupId),
+      onCycleFilter: () => onCycleFilter(),
+      onMoveSelection
+    }
+  );
+}
+var AgentContextMentionPalette = AgentFileMentionPalette;
+function decorateMentionGroup(group, index, groups, filter, query) {
+  const groupId = group.id;
+  const suppressChrome = shouldSuppressFileSearchGroupChrome(filter, query);
+  const followsMySessions = groupId === "collab_sessions" && groups[index - 1]?.id === "my_sessions";
+  const showLabel = shouldRenderMentionGroupLabel({
+    filter,
+    groupCount: groups.length,
+    groupId,
+    query
+  });
+  return {
+    ...group,
+    label: showLabel ? agentMentionGroupLabel(groupId) : void 0,
+    emptyLabel: suppressChrome ? void 0 : agentMentionEmptyGroupLabel(groupId, query),
+    expandLabel: group.hasMore ? translate("agentHost.agentGui.contextPickerExpandMore", {
+      count: mentionGroupExpandCount(group, filter)
+    }) : void 0,
+    sectionClassName: followsMySessions ? "mt-2" : void 0,
+    hideTopDivider: suppressChrome
+  };
+}
+function MentionPaletteLoadingBanner({
+  label
+}) {
+  "use memo";
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex items-center gap-2 border-b border-[var(--line-1)] px-3 py-2 text-[13px] font-medium text-[var(--text-secondary)]",
+      "data-testid": "agent-mention-loading-banner",
+      children: [
+        /* @__PURE__ */ jsx(
+          Spinner,
+          {
+            size: 14,
+            className: "text-[var(--text-secondary)]",
+            testId: "agent-mention-loading-spinner"
+          }
+        ),
+        /* @__PURE__ */ jsx("span", { children: label })
+      ]
+    }
+  );
+}
+function MentionFileSearchMoreHint() {
+  "use memo";
+  return /* @__PURE__ */ jsx(
+    "p",
+    {
+      className: "px-3 pb-1 pt-2 text-center text-[13px] leading-5 text-[var(--text-tertiary)]",
+      "data-agent-mention-file-search-hint": "true",
+      children: translate("agentHost.agentGui.mentionFileSearchMoreHint")
+    }
+  );
+}
+function shouldSuppressFileSearchGroupChrome(filter, query) {
+  return filter === "file" && query.trim().length > 0;
+}
+function resolveMentionPaletteEmptyLabel(input) {
+  if (input.mode === "results" && input.filter === "file" && input.query.trim().length > 0) {
+    return translate("agentHost.agentGui.mentionNoMatchingFiles");
+  }
+  return input.emptyLabel;
+}
+function shouldRenderMentionGroupLabel(input) {
+  if (shouldSuppressFileSearchGroupChrome(input.filter, input.query)) {
+    return false;
+  }
+  if (input.filter === "all" || input.groupCount !== 1) {
+    return true;
+  }
+  return agentMentionGroupLabel(input.groupId) !== agentMentionFilterLabel(input.filter);
+}
+function agentMentionItemToRowItem(item) {
+  if (item.kind === "file") {
+    const visualKind = resolveAgentMentionFileVisualKind({
+      entryKind: item.entryKind,
+      href: item.href,
+      mentionNavigation: item.mentionNavigation,
+      name: item.name,
+      path: item.path
+    });
+    const childCountLabel = item.mentionNavigation === "agent-generated-folder" && typeof item.childCount === "number" && item.childCount > 0 ? translate("agentHost.agentGui.mentionAgentGeneratedFolderFileCount", {
+      count: item.childCount
+    }) : null;
+    return {
+      kind: "file",
+      name: item.name,
+      visualKind,
+      thumbnailUrl: resolveAgentMentionFileThumbnailUrl(item) ?? null,
+      childCountLabel,
+      entryKind: item.entryKind,
+      mentionNavigation: item.mentionNavigation
+    };
+  }
+  if (item.kind === "session") {
+    return {
+      kind: "session",
+      participant: `${item.initiatorName} & ${item.agentName}`,
+      summary: item.title,
+      userAvatarUrl: item.initiatorAvatarUrl ?? null,
+      userAvatarPlaceholderUrl,
+      agentIconUrl: managedAgentRoundedIconUrl(
+        mentionSessionAgentProvider(item) ?? item.agentName
+      ),
+      statusTag: agentSessionStatusTag(item.status)
+    };
+  }
+  if (item.kind === "workspace-app") {
+    return {
+      kind: "app",
+      name: item.name,
+      description: item.description ?? null,
+      iconUrl: item.iconUrl ?? null
+    };
+  }
+  if (item.kind === "workspace-app-factory") {
+    return {
+      kind: "app-factory",
+      name: item.name
+    };
+  }
+  return {
+    kind: "issue",
+    title: item.title,
+    creatorName: item.creatorName ?? null,
+    statusTag: agentIssueStatusTag(item.status)
+  };
+}
+function mentionSessionAgentProvider(item) {
+  const queryStart = item.href.indexOf("?");
+  if (queryStart < 0) {
+    return null;
+  }
+  return new URLSearchParams(item.href.slice(queryStart + 1)).get("provider");
+}
+function agentSessionStatusTag(status) {
+  if (!status) {
+    return null;
+  }
+  const activityStatus = normalizeAgentActivityDisplayStatus(status);
+  return {
+    label: workspaceAgentActivityStatusLabel(activityStatus),
+    tone: mentionStatusTone(activityStatus),
+    pulse: activityStatus === "working" || activityStatus === "waiting",
+    variant: "activity",
+    dataStatus: activityStatus
+  };
+}
+function agentIssueStatusTag(status) {
+  if (!status) {
+    return null;
+  }
+  return {
+    label: roomIssueStatusLabel(status),
+    tone: issueMentionStatusTone(status),
+    variant: "issue",
+    dataStatus: status.trim().toLowerCase() || "not_started"
+  };
+}
+function mentionStatusTone(status) {
+  if (status === "working") {
+    return "blue";
+  }
+  if (status === "waiting" || status === "canceled") {
+    return "amber";
+  }
+  if (status === "completed" || status === "idle") {
+    return "green";
+  }
+  if (status === "failed") {
+    return "red";
+  }
+  return "neutral";
+}
+function browseHintForFilter(filter) {
+  if (filter === "all") {
+    return translate("agentHost.agentGui.contextPickerBrowseAllHint");
+  }
+  switch (filter) {
+    case "app":
+      return translate("agentHost.agentGui.contextPickerBrowseAppHint");
+    case "file":
+      return translate("agentHost.agentGui.contextPickerBrowseFileHint");
+    case "session":
+      return translate("agentHost.agentGui.contextPickerBrowseSessionHint");
+    case "issue":
+      return translate("agentHost.agentGui.contextPickerBrowseIssueHint");
+  }
+}
+function isBrowseCategoryId(value) {
+  return value === "all" || value === "app" || value === "file" || value === "session" || value === "issue";
+}
+function hasInteractiveGroupEntries(groups) {
+  return groups.some((group) => group.items.length > 0 || group.hasMore);
+}
+function isFileBrowseGroupsOnlyEmpty(groups) {
+  const fileGroups = groups.filter(
+    (group) => group.id === "opened_files" || group.id === "agent_generated_files"
+  );
+  if (fileGroups.length === 0) {
+    return false;
+  }
+  return fileGroups.every(
+    (group) => group.items.length === 0 && !group.hasMore
+  );
+}
+function hasVisibleFileGroupEntries(groups) {
+  return groups.some(
+    (group) => (group.id === "files" || group.id === "opened_files" || group.id === "agent_generated_files") && (group.items.length > 0 || group.hasMore)
+  );
+}
+function shouldShowFileSearchMoreHint(input) {
+  if (input.filter !== "file" || input.query.trim()) {
+    return false;
+  }
+  if (input.mode !== "browse" && input.mode !== "results") {
+    return false;
+  }
+  return hasVisibleFileGroupEntries(input.groups);
+}
+function shouldShowBrowseSearchHint(input) {
+  if (input.mode !== "browse" || hasInteractiveGroupEntries(input.groups)) {
+    return false;
+  }
+  if (input.groups.length === 0) {
+    return true;
+  }
+  if (input.highlightedBrowseCategory !== null && input.highlightedBrowseCategory !== input.browseFilter) {
+    return true;
+  }
+  return input.browseFilter === "file" && isFileBrowseGroupsOnlyEmpty(input.groups);
+}
+
+export {
+  AGENT_MENTION_FILTER_TAB_ORDER,
+  AgentMentionSearchController,
+  flattenAgentMentionPaletteEntries,
+  groupStartKeys,
+  AgentFileMentionPalette,
+  AgentContextMentionPalette
+};
+//# sourceMappingURL=chunk-3YZX5EUC.js.map