/**
 * @file CcConfig.tsx
 * @description Claude Code configuration explorer. Surfaces every plugin,
 * skill, subagent, slash command, MCP server, hook, settings file, memory
 * file, marketplace, keybinding, and statusline script Claude Code knows
 * about. Read access for all surfaces; create / edit / delete for the
 * low-risk text-file surfaces (skills, agents, commands, output styles,
 * CLAUDE.md memory, and per-project file-based memory files). Plugins, MCP,
 * hooks-in-settings, and settings.json files stay read-only - those have
 * concurrent-write races with the live CLI. Its Overview also holds the
 * dashboard's own Claude Code settings (CLAUDE_HOME — editable, so the path
 * list leaves it out — hooks, pricing: `ClaudeAgentHubSettings`).
 * The toolbar's Switch profile button links to Settings → AI tools → Profiles
 * (`ToolProfilesSettings`), where every AI tool's login profiles live.
 * Every card with action buttons (plugins, marketplaces, MCP servers, memory
 * files, and the `MdItemList` artifacts) also opens a
 * right-click menu that repeats those buttons — same handlers, same
 * confirm path — plus Copy name/path.
 * @author Nguyễn Ngọc Trí Vĩ <vinnt@smartgift.vn>
 */
/* =============================================================================
 * MODULE_GUIDE — extended in-file reference (comments only; safe to read, never executed)
 * =============================================================================
 * **Purpose:** Dashboard module consumed by the React client, MCP tools, or desktop shell depending on deployment mode.
 *
 * ## Design constraints
 * - Local-first: no telemetry leaves the machine unless the user configures webhooks.
 * - Fail-safe hooks path on the server must never block Claude Code; UI mirrors that
 *   philosophy by degrading gracefully (empty states, stale badges, reconnect loops).
 * - Destructive flows stay behind explicit confirmation modals and server-side gates.
 * - Internationalization: user-visible strings belong in i18n JSON, not literals here.
 *
 * ## Remote data & SSH
 * Remote Data Sources let operators aggregate multiple machines. SSH entries describe
 * how to reach a peer dashboard; the global data scope (`dataScope.ts`) narrows every
 * scoped GET via `?sources=`. Health checks and import history surface in Settings.
 *
 * ## Internal dependencies
 * - `../lib/eventBus`
 * - `../lib/api`
 *
 * ## Public surface
 * - `CcConfig` — exported API; see TSDoc on the symbol for behavior.
 *
 * ## Testing pointers
 * - Prefer colocated `__tests__` with Vitest + Testing Library for UI.
 * - Server contract changes require `npm run test:server` and OpenAPI sync.
 *
 * ## Related docs
 * - `ARCHITECTURE.md` — hooks → API → SQLite → WebSocket → UI pipeline.
 * - `docs/API.md` — REST reference.
 * - `skills/file-headers/` — mandatory `@author` header policy.
 * ============================================================================= */
/* -----------------------------------------------------------------------------
 * EXPORT CATALOG — quick index of symbols defined below (documentation only).
 * -----------------------------------------------------------------------------
 * **CcConfig**
 *   Part of this module's public contract. Downstream imports should treat
 *   the signature and return type as stable unless release notes say otherwise.
 *   When behavior changes, update the `@file` overview and relevant tests.
 *
 * ----------------------------------------------------------------------------- */

import { useCallback, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
import { useTranslation } from "react-i18next";
import { Link, useSearchParams } from "react-router-dom";
import { useSettingsHref } from "../lib/settingsLink";
import { eventBus } from "../lib/eventBus";
import {
  Boxes,
  RefreshCw,
  Search,
  Sparkles,
  UserRound,
  FolderTree,
  Wrench,
  Slash,
  Palette,
  PlugZap,
  Server,
  Webhook,
  Settings as SettingsIcon,
  BookOpen,
  FileText,
  Copy,
  Check,
  AlertCircle,
  ExternalLink,
  X,
  Info,
  Pencil,
  Trash2,
  Plus,
  Save,
  Lock,
  History,
  Terminal,
  Store,
  Keyboard,
  CircleDot,
  CircleSlash,
  ChevronDown,
  UserCog,
  ArrowUpCircle,
  RotateCw,
  CheckCircle2,
  XCircle,
  MinusCircle,
} from "lucide-react";
import { api } from "../lib/api";
import { FileViewer } from "../components/config/FileViewer";
import { EditorModal, type EditorState } from "../components/config/EditorModal";
import {
  ConfirmDeleteModal,
  type ConfirmDeleteState,
} from "../components/config/ConfirmDeleteModal";
import { showToast, type Toast } from "../components/config/ToastNotice";
import { confirmDialog, confirmDiscard } from "../lib/confirm";
import { copyText } from "../lib/clipboard";
import { useDialog } from "../hooks/useDialog";
import { useUnsavedGuard } from "../hooks/useUnsavedGuard";
import { useArmed } from "../hooks/useArmed";
import { FileItemMenu, MdItemList } from "../components/config/MdItemList";
import { ContextMenu, MenuItem, MenuSeparator, useContextMenu } from "../components/ContextMenu";
import { ScopeBadge } from "../components/config/ScopeBadge";
import { ConfigTabBar } from "../components/config/ConfigTabBar";
import { ProjectMemoryModal } from "../components/config/ProjectMemoryModal";
import { ClaudeAgentHubSettings } from "../components/settings/ClaudeAgentHubSettings";
import {
  Empty,
  SkeletonRows,
  CopyButton,
  formatBytes,
} from "../components/config/configPrimitives";
import type {
  CcArtifactType,
  CcAvailablePlugin,
  CcBackup,
  CcFileResponse,
  CcHookEntry,
  CcHookScripts,
  CcHookSource,
  CcKeybindings,
  CcKeybindingGroup,
  CcMarketplacesResponse,
  CcMcpAddArgs,
  CcMcpResponse,
  CcMcpScope,
  CcMcpServer,
  CcMdItem,
  CcMemoryItem,
  CcMutationResult,
  CcOverview,
  CcPlugin,
  CcPluginItem,
  CcPluginsResponse,
  CcUpdateAllBatch,
  CcScope,
  CcSettingsSource,
  CcStatusline,
} from "../lib/api";
import { isSubmitEnter } from "../lib/keys";

/** How an inline editor reports unsaved edits to the page. */
type OnDirty = (id: string, dirty: boolean) => void;

/**
 * Report an inline editor's unsaved state to the page (tab switches ask) and
 * to the browser (closing the tab asks).
 */
function useReportDirty(id: string, dirty: boolean, onDirty: OnDirty | undefined): void {
  useEffect(() => {
    onDirty?.(id, dirty);
    return () => onDirty?.(id, false);
  }, [id, dirty, onDirty]);
  useUnsavedGuard(dirty);
}

function isMutable(
  tab: TabKey
): tab is "skills" | "agents" | "commands" | "outputStyles" | "memory" {
  return (
    tab === "skills" ||
    tab === "agents" ||
    tab === "commands" ||
    tab === "outputStyles" ||
    tab === "memory"
  );
}

function tabToArtifactType(
  tab: "skills" | "agents" | "commands" | "outputStyles" | "memory"
): CcArtifactType {
  return tab === "outputStyles" ? "output-styles" : tab;
}

type TabKey =
  | "overview"
  | "skills"
  | "agents"
  | "commands"
  | "outputStyles"
  | "plugins"
  | "marketplaces"
  | "mcp"
  | "hooks"
  | "keybindings"
  | "settings"
  | "memory";

interface TabDef {
  key: TabKey;
  icon: typeof Sparkles;
  i18nKey: string;
  /** i18n key of the tab's group label (Content · Extensions · Config). */
  group?: string;
}

const TABS: TabDef[] = [
  { key: "overview", icon: Boxes, i18nKey: "tabs.overview" },
  { key: "skills", icon: Sparkles, i18nKey: "tabs.skills", group: "tabGroups.content" },
  { key: "agents", icon: UserRound, i18nKey: "tabs.agents", group: "tabGroups.content" },
  { key: "commands", icon: Slash, i18nKey: "tabs.commands", group: "tabGroups.content" },
  { key: "outputStyles", icon: Palette, i18nKey: "tabs.outputStyles", group: "tabGroups.content" },
  { key: "memory", icon: BookOpen, i18nKey: "tabs.memory", group: "tabGroups.content" },
  { key: "plugins", icon: PlugZap, i18nKey: "tabs.plugins", group: "tabGroups.extensions" },
  { key: "marketplaces", icon: Store, i18nKey: "tabs.marketplaces", group: "tabGroups.extensions" },
  { key: "mcp", icon: Server, i18nKey: "tabs.mcp", group: "tabGroups.extensions" },
  { key: "hooks", icon: Webhook, i18nKey: "tabs.hooks", group: "tabGroups.extensions" },
  { key: "settings", icon: SettingsIcon, i18nKey: "tabs.settings", group: "tabGroups.config" },
  { key: "keybindings", icon: Keyboard, i18nKey: "tabs.keybindings", group: "tabGroups.config" },
];

interface PageState {
  overview: CcOverview | null;
  skills: CcMdItem[] | null;
  agents: CcMdItem[] | null;
  commands: CcMdItem[] | null;
  outputStyles: CcMdItem[] | null;
  plugins: CcPluginsResponse | null;
  marketplaces: CcMarketplacesResponse | null;
  mcp: CcMcpResponse | null;
  hooks: CcHookSource[] | null;
  keybindings: CcKeybindings | null;
  settings: CcSettingsSource[] | null;
  memory: CcMemoryItem[] | null;
  statusline: CcStatusline | null;
  hookScripts: CcHookScripts | null;
}

const EMPTY_STATE: PageState = {
  overview: null,
  skills: null,
  agents: null,
  commands: null,
  outputStyles: null,
  plugins: null,
  marketplaces: null,
  mcp: null,
  hooks: null,
  keybindings: null,
  settings: null,
  memory: null,
  statusline: null,
  hookScripts: null,
};

/** Which page-state keys each tab displays (their load errors show there). */
const TAB_KEYS: Record<TabKey, (keyof PageState)[]> = {
  overview: ["overview"],
  skills: ["skills"],
  agents: ["agents"],
  commands: ["commands"],
  outputStyles: ["outputStyles"],
  plugins: ["plugins"],
  marketplaces: ["marketplaces"],
  mcp: ["mcp"],
  hooks: ["hooks", "hookScripts"],
  keybindings: ["keybindings"],
  settings: ["settings", "statusline"],
  memory: ["memory"],
};

/** The four lists the All / User / Project toggle actually filters. */
const SCOPED_TABS: TabKey[] = ["skills", "agents", "commands", "outputStyles"];
const SCOPED_KEYS: (keyof PageState)[] = ["skills", "agents", "commands", "outputStyles"];
const ALL_KEYS = Object.keys(EMPTY_STATE) as (keyof PageState)[];

/** One loader per page-state key, so a change refetches only what it touched. */
function loadKey(key: keyof PageState, scope: CcScope): Promise<unknown> {
  switch (key) {
    case "overview":
      return api.ccConfig.overview();
    case "skills":
      return api.ccConfig.skills(scope).then((r) => r.items);
    case "agents":
      return api.ccConfig.agents(scope).then((r) => r.items);
    case "commands":
      return api.ccConfig.commands(scope).then((r) => r.items);
    case "outputStyles":
      return api.ccConfig.outputStyles(scope).then((r) => r.items);
    case "plugins":
      return api.ccConfig.plugins();
    case "marketplaces":
      return api.ccConfig.marketplaces();
    case "mcp":
      return api.ccConfig.mcp();
    case "hooks":
      return api.ccConfig.hooks().then((r) => r.items);
    case "keybindings":
      return api.ccConfig.keybindings();
    case "settings":
      return api.ccConfig.settings().then((r) => r.items);
    case "memory":
      return api.ccConfig.memory().then((r) => r.items);
    case "statusline":
      return api.ccConfig.statusline();
    case "hookScripts":
      return api.ccConfig.hookScripts();
  }
}

/**
 * The page-state keys a `cc_config_changed` message touches. The watcher sends
 * the changed `paths`, a dashboard mutation its artifact `type`; anything we
 * cannot place reloads everything. The overview's counts always reload.
 * @param msg The websocket message's data.
 */
export function keysForChange(msg: {
  source?: string;
  paths?: unknown;
  type?: unknown;
}): (keyof PageState)[] {
  const out = new Set<keyof PageState>(["overview"]);
  const all = () => ALL_KEYS;
  if (Array.isArray(msg.paths) && msg.paths.length > 0) {
    for (const raw of msg.paths) {
      const p = String(raw).replace(/\\/g, "/");
      if (/\/skills(\/|$)/.test(p)) out.add("skills");
      else if (/\/agents(\/|$)/.test(p)) out.add("agents");
      else if (/\/commands(\/|$)/.test(p)) out.add("commands");
      else if (/\/output-styles(\/|$)/.test(p)) out.add("outputStyles");
      else if (/\/hooks(\/|$)/.test(p)) (out.add("hooks"), out.add("hookScripts"));
      else if (/keybindings\.json$/.test(p)) out.add("keybindings");
      else if (/settings(\.local)?\.json$/.test(p))
        (out.add("settings"), out.add("hooks"), out.add("statusline"), out.add("hookScripts"));
      else if (/CLAUDE\.md$|\/memory\//.test(p)) out.add("memory");
      else if (/\/plugins(\/|$)/.test(p)) (out.add("plugins"), out.add("marketplaces"));
      else if (/\.claude\.json$/.test(p))
        (out.add("mcp"), out.add("marketplaces"), out.add("plugins"));
      else return all();
    }
    return [...out];
  }
  switch (msg.type) {
    case "skills":
    case "agents":
    case "commands":
    case "memory":
    case "keybindings":
      out.add(msg.type);
      return [...out];
    case "output-styles":
      out.add("outputStyles");
      return [...out];
    case "auto-memory":
      out.add("memory");
      return [...out];
    case "settings":
      return [...out, "settings", "hooks", "statusline", "hookScripts"];
    case "profile":
      return [...out];
    default:
      return all();
  }
}

/** A project root inside Claude Code's plugin cache is replaced on every
 *  plugin update, so nothing written there survives. */
export function isPluginCachePath(p: string | null | undefined): boolean {
  return !!p && /\/\.claude\/plugins\/cache(\/|$)/.test(p.replace(/\\/g, "/"));
}

export function CcConfig() {
  const { t } = useTranslation("ccConfig");
  // The tab lives in the URL (`?tab=`, replaced) so search results, deep links
  // and Back land on it.
  const [params, setParams] = useSearchParams();
  const rawTab = params.get("tab");
  const urlTab: TabKey = TABS.some((d) => d.key === rawTab) ? (rawTab as TabKey) : "overview";
  // Editors inside a tab report unsaved edits here (by id), so leaving the tab
  // asks first instead of silently dropping the draft.
  const dirtyIds = useRef(new Set<string>());
  const setDirty = useCallback((id: string, d: boolean) => {
    if (d) dirtyIds.current.add(id);
    else dirtyIds.current.delete(id);
  }, []);
  const writeTab = useCallback(
    (k: TabKey) =>
      setParams(
        (prev) => {
          const next = new URLSearchParams(prev);
          if (k === "overview") next.delete("tab");
          else next.set("tab", k);
          return next;
        },
        { replace: true }
      ),
    [setParams]
  );
  // The tab shown follows the URL, but only once an unsaved edit is let go:
  // the URL also changes from outside the tab bar (a settings search result,
  // Back), and those must ask too. Kept, the URL goes back to the shown tab.
  const [tab, setShownTab] = useState<TabKey>(urlTab);
  useEffect(() => {
    if (urlTab === tab) return;
    let live = true;
    void (async () => {
      if (dirtyIds.current.size > 0 && !(await confirmDiscard())) {
        if (live) writeTab(tab);
        return;
      }
      if (!live) return;
      dirtyIds.current.clear();
      setShownTab(urlTab);
    })();
    return () => {
      live = false;
    };
  }, [urlTab, tab, writeTab]);
  const setTab = useCallback((k: TabKey) => writeTab(k), [writeTab]);
  // Bumped by Refresh: the AgentHub cards load on mount, so a new key reloads them.
  const [agenthubKey, setAgenthubKey] = useState(0);
  const [scope, setScope] = useState<CcScope>("all");
  const [data, setData] = useState<PageState>(EMPTY_STATE);
  const [loading, setLoading] = useState(false);
  const [errors, setErrors] = useState<Partial<Record<keyof PageState, string>>>({});
  const [lastUpdated, setLastUpdated] = useState<Date | null>(null);
  // One search box per tab: a filter typed on Skills must not hide Plugins.
  const [searches, setSearches] = useState<Partial<Record<TabKey, string>>>({});
  const search = searches[tab] ?? "";
  const setSearch = (v: string) => setSearches((s) => ({ ...s, [tab]: v }));
  const [viewer, setViewer] = useState<{
    path: string;
    data: CcFileResponse | null;
    error: string | null;
  } | null>(null);
  const [editor, setEditor] = useState<EditorState>(null);
  const [confirmDelete, setConfirmDelete] = useState<ConfirmDeleteState>(null);
  const setToast = showToast;
  const [backupsOpen, setBackupsOpen] = useState(false);
  const [projectMemoryOpen, setProjectMemoryOpen] = useState(false);

  const scopeRef = useRef(scope);
  scopeRef.current = scope;
  /** Reload some page-state keys; one failing endpoint never blanks the rest. */
  const fetchKeys = useCallback(async (keys: (keyof PageState)[]) => {
    setLoading(true);
    const results = await Promise.allSettled(keys.map((k) => loadKey(k, scopeRef.current)));
    const patch: Partial<PageState> = {};
    const errs: Partial<Record<keyof PageState, string>> = {};
    results.forEach((r, i) => {
      const k = keys[i]!;
      if (r.status === "fulfilled") (patch as Record<string, unknown>)[k] = r.value;
      else errs[k] = r.reason instanceof Error ? r.reason.message : "unknown error";
    });
    setData((d) => ({ ...d, ...patch }));
    setErrors((e) => {
      const next = { ...e };
      for (const k of keys) delete next[k];
      return { ...next, ...errs };
    });
    setLastUpdated(new Date());
    setLoading(false);
  }, []);
  const fetchAll = useCallback(() => fetchKeys(ALL_KEYS), [fetchKeys]);

  useEffect(() => {
    void fetchAll();
  }, [fetchAll]);
  // A scope change reloads only the four lists it filters.
  const firstScope = useRef(true);
  useEffect(() => {
    if (firstScope.current) {
      firstScope.current = false;
      return;
    }
    void fetchKeys(SCOPED_KEYS);
  }, [scope, fetchKeys]);

  // Live updates - refetch what the server says changed (dashboard mutations
  // or external file edits picked up by the cc-watcher). Debounced because a
  // single user action can write multiple files (e.g. a skill backup + the
  // skill itself + the file-history snapshot all land within tens of ms).
  const refetchTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const pendingKeys = useRef(new Set<keyof PageState>());
  useEffect(() => {
    return eventBus.subscribe((msg) => {
      if (msg.type !== "cc_config_changed") return;
      for (const k of keysForChange((msg.data ?? {}) as Parameters<typeof keysForChange>[0]))
        pendingKeys.current.add(k);
      if (refetchTimerRef.current) clearTimeout(refetchTimerRef.current);
      refetchTimerRef.current = setTimeout(() => {
        refetchTimerRef.current = null;
        const keys = [...pendingKeys.current];
        pendingKeys.current.clear();
        void fetchKeys(keys);
      }, 250);
    });
  }, [fetchKeys]);
  useEffect(() => {
    return () => {
      if (refetchTimerRef.current) clearTimeout(refetchTimerRef.current);
    };
  }, []);

  const wsConnected = useSyncExternalStore(eventBus.onConnection, () => eventBus.connected);
  const projectRoot = data.overview?.roots.projectRoot ?? null;
  // Project files under the plugin cache are wiped by the next plugin update.
  const projectDisabled = isPluginCachePath(projectRoot);
  useEffect(() => {
    if (projectDisabled && scope === "project") setScope("all");
  }, [projectDisabled, scope]);
  const tabErrors = TAB_KEYS[tab].map((k) => errors[k]).filter(Boolean) as string[];

  const openViewer = useCallback(async (path: string) => {
    setViewer({ path, data: null, error: null });
    try {
      const file = await api.ccConfig.file(path);
      setViewer({ path, data: file, error: null });
    } catch (err: unknown) {
      const msg = err instanceof Error ? err.message : "unknown error";
      setViewer({ path, data: null, error: msg });
    }
  }, []);

  const openCreate = useCallback(
    (type: CcArtifactType, overrideScope?: "user" | "project") => {
      const tplKey = `edit.templates.${type}`;
      const template = t(tplKey);
      const defaultScope: "user" | "project" =
        overrideScope ?? (scope === "project" && !projectDisabled ? "project" : "user");
      setEditor({ mode: "create", type, defaultScope, template });
    },
    [scope, t, projectDisabled]
  );

  const openEdit = useCallback(
    (type: CcArtifactType, item: { scope: "user" | "project"; name: string; filePath: string }) => {
      setEditor({
        mode: "edit",
        type,
        scope: item.scope,
        name: item.name,
        filePath: item.filePath,
      });
    },
    []
  );

  const openDelete = useCallback(
    (
      type: CcArtifactType,
      scopeArg: "user" | "project",
      name: string | undefined,
      path: string
    ) => {
      setConfirmDelete({ type, scope: scopeArg, name, path });
    },
    []
  );

  // ── Auto-memory (per-project file-based memory) create / edit / delete ──
  const openCreateAuto = useCallback(
    (project: string) => {
      setEditor({
        mode: "create",
        type: "auto-memory",
        defaultScope: "user", // unused for auto-memory; scope is fixed
        template: t("edit.templates.auto-memory"),
        project,
      });
    },
    [t]
  );

  const openEditAuto = useCallback((item: CcMemoryItem) => {
    if (!item.project || !item.name) return;
    setEditor({
      mode: "edit",
      type: "auto-memory",
      scope: "auto-memory",
      name: item.name,
      filePath: item.file,
      project: item.project,
    });
  }, []);

  const openDeleteAuto = useCallback((item: CcMemoryItem) => {
    if (!item.project || !item.name) return;
    setConfirmDelete({
      type: "auto-memory",
      scope: "auto-memory",
      name: item.name,
      path: item.file,
      project: item.project,
    });
  }, []);

  const handleSave = useCallback(
    async (args: {
      type: CcArtifactType;
      targetScope: "user" | "project" | "auto-memory";
      name: string | undefined;
      content: string;
      project?: string;
    }) => {
      const result: CcMutationResult = await api.ccConfig.write({
        scope: args.targetScope,
        type: args.type,
        name: args.name,
        content: args.content,
        project: args.project,
      });
      setEditor(null);
      setToast({
        kind: "success",
        message: result.created
          ? t("edit.saveSuccessNew")
          : t("edit.saveSuccess", { path: result.backupPath || "-" }),
      });
      void fetchAll();
    },
    [fetchAll, t]
  );

  // Create CLAUDE.md in ANOTHER project's directory. Deliberately not part of
  // `handleSave`: that one writes this machine's user/project layers through
  // the artifact writer, while this names its own target directory.
  const handleCreateProjectMemory = useCallback(
    async (args: { dir: string; content: string }) => {
      const result = await api.ccConfig.createProjectMemory(args);
      setProjectMemoryOpen(false);
      setToast({ kind: "success", message: t("projectMemory.created", { path: result.file }) });
      void fetchAll();
      return result.file;
    },
    [fetchAll, t]
  );

  const handleDelete = useCallback(async () => {
    if (!confirmDelete) return;
    try {
      const result = await api.ccConfig.delete({
        scope: confirmDelete.scope,
        type: confirmDelete.type,
        name: confirmDelete.name,
        project: confirmDelete.project,
      });
      setConfirmDelete(null);
      setToast({
        kind: "success",
        message: t("edit.deleteSuccess", { path: result.backupPath || "-" }),
      });
      void fetchAll();
    } catch (err: unknown) {
      const msg = err instanceof Error ? err.message : "unknown error";
      setConfirmDelete(null);
      setToast({ kind: "error", message: t("edit.deleteError", { message: msg }) });
    }
  }, [confirmDelete, fetchAll, t]);

  return (
    <div className="space-y-5">
      <Header
        loading={loading}
        lastUpdated={lastUpdated}
        onRefresh={() => {
          void fetchAll();
          setAgenthubKey((k) => k + 1);
        }}
        onOpenBackups={() => setBackupsOpen(true)}
        wsConnected={wsConnected}
      />

      <Tabs current={tab} onSelect={(k) => void setTab(k)} counts={data.overview?.counts} />

      <div
        id="cc-tabpanel"
        role="tabpanel"
        aria-labelledby={`cc-tab-${tab}`}
        className="rounded-xl border border-border bg-surface-1"
      >
        {tabErrors.length > 0 && (
          <div
            role="alert"
            className="m-4 mb-0 rounded-lg border border-status-danger/40 bg-status-danger/10 px-4 py-3 text-sm text-status-danger flex items-center gap-2"
          >
            <AlertCircle className="w-4 h-4 flex-shrink-0" />
            <span>{t("loadError", { message: tabErrors.join(" · ") })}</span>
          </div>
        )}
        {tab !== "overview" && (
          <div className="flex flex-wrap items-center gap-2 border-b border-border px-4 py-2.5">
            <div className="flex flex-1 min-w-[12rem] items-center gap-2 rounded-md px-1 focus-within:ring-2 focus-within:ring-accent/40">
              <Search className="w-4 h-4 text-fg-muted" aria-hidden />
              <input
                value={search}
                onChange={(e) => setSearch(e.target.value)}
                placeholder={t("common.search")}
                aria-label={t("common.search")}
                className="h-7 bg-transparent text-sm text-fg-primary placeholder:text-fg-muted focus:outline-none flex-1"
              />
              {search && (
                <button
                  type="button"
                  onClick={() => setSearch("")}
                  title={t("common.clearSearch")}
                  aria-label={t("common.clearSearch")}
                  className="h-7 w-7 flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-fg-secondary hover:bg-surface-3 focus:outline-none focus:ring-1 focus:ring-accent/40"
                >
                  <X className="w-3.5 h-3.5" />
                </button>
              )}
            </div>
            {SCOPED_TABS.includes(tab) && (
              <ScopeToggle
                value={scope}
                onChange={setScope}
                projectRoot={projectRoot}
                projectDisabled={projectDisabled}
              />
            )}
            {isMutable(tab) && tab !== "memory" && (
              <button
                type="button"
                onClick={() => openCreate(tabToArtifactType(tab))}
                className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5"
              >
                <Plus className="w-3 h-3" />
                {t("edit.newButton")}
              </button>
            )}
            {/* The memory tab's own "new" is a different thing: the two
                CLAUDE.md cards below are this machine's user + current-project
                files, while this creates one in ANOTHER project's directory. */}
            {tab === "memory" && (
              <button
                type="button"
                onClick={() => setProjectMemoryOpen(true)}
                className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 whitespace-nowrap"
              >
                <Plus className="w-3 h-3" />
                {t("projectMemory.newButton")}
              </button>
            )}
          </div>
        )}
        <div className="p-4">
          <TabPanel
            tab={tab}
            data={data}
            search={search}
            onOpenFile={openViewer}
            onEdit={openEdit}
            onDelete={openDelete}
            onCreateMemory={(s) => openCreate("memory", s)}
            onEditAuto={openEditAuto}
            onDeleteAuto={openDeleteAuto}
            onCreateAuto={openCreateAuto}
            onChanged={fetchAll}
            onToast={setToast}
            onDirty={setDirty}
          />
        </div>
      </div>

      {/* AgentHub's own Claude Code settings follow the overview, outside the
          list's search box and scope. */}
      {tab === "overview" && (
        <ClaudeAgentHubSettings key={agenthubKey} onHomeChanged={() => void fetchAll()} />
      )}

      {viewer && <FileViewer state={viewer} onClose={() => setViewer(null)} />}
      {editor && (
        <EditorModal
          state={editor}
          fetchContent={(p) => api.ccConfig.file(p)}
          onClose={() => setEditor(null)}
          onSave={handleSave}
          projectDisabled={projectDisabled}
        />
      )}
      {confirmDelete && (
        <ConfirmDeleteModal
          state={confirmDelete}
          onCancel={() => setConfirmDelete(null)}
          onConfirm={handleDelete}
        />
      )}
      {projectMemoryOpen && (
        <ProjectMemoryModal
          ns="ccConfig"
          filename="CLAUDE.md"
          template={t("projectMemory.template")}
          onClose={() => setProjectMemoryOpen(false)}
          onCreate={handleCreateProjectMemory}
        />
      )}
      {backupsOpen && <BackupsModal onClose={() => setBackupsOpen(false)} />}
    </div>
  );
}

// ── Header ────────────────────────────────────────────────────────────

interface HeaderProps {
  loading: boolean;
  lastUpdated: Date | null;
  onRefresh: () => void;
  onOpenBackups: () => void;
  wsConnected: boolean;
}

/** The page's toolbar. No title of its own: the Settings hub already draws one. */
function Header({ loading, lastUpdated, onRefresh, onOpenBackups, wsConnected }: HeaderProps) {
  const { t } = useTranslation("ccConfig");
  const settingsHref = useSettingsHref();
  const { t: tCommon } = useTranslation("common");
  const formatted = lastUpdated
    ? lastUpdated.toLocaleTimeString(undefined, {
        hour: "2-digit",
        minute: "2-digit",
        second: "2-digit",
      })
    : "-";
  return (
    <header className="flex flex-col gap-3 lg:flex-row lg:items-start lg:justify-between">
      <div className="flex items-start gap-2 min-w-0 flex-1">
        {wsConnected ? (
          <span className="flex items-center gap-1.5 text-[11px] text-status-success bg-status-success/10 border border-status-success/20 px-2 py-0.5 rounded-full flex-shrink-0">
            <span className="w-1.5 h-1.5 rounded-full bg-status-success animate-pulse-dot" />
            {tCommon("live")}
          </span>
        ) : (
          <span className="flex items-center gap-1.5 text-[11px] text-fg-secondary bg-surface-4/10 border border-border-light/20 px-2 py-0.5 rounded-full flex-shrink-0">
            <span className="w-1.5 h-1.5 rounded-full bg-surface-4" />
            {tCommon("offline")}
          </span>
        )}
        <p className="text-xs text-fg-muted max-w-2xl">{t("subtitle")}</p>
      </div>
      <div className="flex flex-col items-stretch lg:items-end gap-2 flex-shrink-0">
        <div className="flex items-center gap-2 justify-end flex-wrap">
          {/* Every AI tool's login profiles live in one place: Settings → AI tools. */}
          <Link
            to={settingsHref("agents#tool-profiles")}
            className="inline-flex items-center gap-2 rounded-lg border border-border bg-surface-2 px-3 py-1.5 text-xs font-medium text-fg-secondary hover:bg-surface-3 transition-colors"
          >
            <UserCog className="w-3.5 h-3.5" />
            {t("profiles.openButton")}
          </Link>
          <button
            type="button"
            onClick={onOpenBackups}
            className="inline-flex items-center gap-2 rounded-lg border border-border bg-surface-2 px-3 py-1.5 text-xs font-medium text-fg-secondary hover:bg-surface-3 transition-colors"
          >
            <History className="w-3.5 h-3.5" />
            {t("backups.openButton")}
          </button>
          <button
            type="button"
            onClick={onRefresh}
            disabled={loading}
            className="inline-flex items-center gap-2 rounded-lg border border-border bg-surface-2 px-3 py-1.5 text-xs font-medium text-fg-secondary hover:bg-surface-3 disabled:opacity-60 transition-colors"
          >
            <RefreshCw className={`w-3.5 h-3.5 ${loading ? "animate-spin" : ""}`} />
            {/* Both labels occupy the same grid cell, so the button is always as
                wide as the longer one ("Refreshing…" / "Đang làm mới…") and does
                not resize the toolbar when the state flips. Measuring the widest
                string beats a hardcoded min-width, which would be wrong in the
                next translation. */}
            <span className="grid">
              <span aria-hidden className="invisible col-start-1 row-start-1 whitespace-nowrap">
                {t("refreshing")}
              </span>
              <span className="col-start-1 row-start-1 whitespace-nowrap">
                {loading ? t("refreshing") : t("refresh")}
              </span>
            </span>
          </button>
        </div>
        {lastUpdated && (
          <span className="text-[11px] text-fg-muted self-end">
            {t("lastUpdated", { time: formatted })}
          </span>
        )}
      </div>
    </header>
  );
}

/** All / User / Project for the four scoped lists, naming the folder "Project"
 *  resolves to — and refusing it when that folder is the plugin cache. */
function ScopeToggle({
  value,
  onChange,
  projectRoot,
  projectDisabled,
}: {
  value: CcScope;
  onChange: (s: CcScope) => void;
  projectRoot: string | null;
  projectDisabled: boolean;
}) {
  const { t } = useTranslation("ccConfig");
  const opts: { v: CcScope; label: string }[] = [
    { v: "all", label: t("scope.all") },
    { v: "user", label: t("scope.user") },
    { v: "project", label: t("scope.project") },
  ];
  return (
    <div className="flex items-center gap-2 min-w-0">
      <div
        role="group"
        aria-label={t("common.scopeLabel")}
        className="inline-flex rounded-lg border border-border bg-surface-2 p-0.5 flex-shrink-0"
      >
        {opts.map((o) => {
          const disabled = o.v === "project" && projectDisabled;
          return (
            <button
              key={o.v}
              type="button"
              aria-pressed={value === o.v}
              disabled={disabled}
              title={
                disabled
                  ? t("scope.projectInCache")
                  : o.v === "project" && projectRoot
                    ? projectRoot
                    : undefined
              }
              onClick={() => onChange(o.v)}
              className={`px-2.5 py-1 text-[11px] font-medium rounded-md transition-colors disabled:opacity-40 disabled:cursor-not-allowed ${
                value === o.v
                  ? "bg-accent/20 text-accent border border-accent/30"
                  : "text-fg-secondary hover:text-fg-primary"
              }`}
            >
              {o.label}
            </button>
          );
        })}
      </div>
      {projectRoot && (
        <span
          className={`truncate font-mono text-[10px] ${projectDisabled ? "text-status-warning" : "text-fg-muted"}`}
          title={projectDisabled ? t("scope.projectInCache") : projectRoot}
        >
          {t("scope.projectIs", { path: projectRoot })}
        </span>
      )}
    </div>
  );
}

// ── Tabs ──────────────────────────────────────────────────────────────

interface TabsProps {
  current: TabKey;
  onSelect: (k: TabKey) => void;
  counts?: CcOverview["counts"];
}

function Tabs({ current, onSelect, counts }: TabsProps) {
  const { t } = useTranslation("ccConfig");
  const countFor = (key: TabKey): number | null => {
    if (!counts) return null;
    switch (key) {
      case "skills":
        return counts.skills.user + counts.skills.project;
      case "agents":
        return counts.agents.user + counts.agents.project;
      case "commands":
        return counts.commands.user + counts.commands.project;
      case "outputStyles":
        return counts.outputStyles.user + counts.outputStyles.project;
      case "plugins":
        return counts.plugins;
      case "marketplaces":
        return counts.marketplaces;
      case "keybindings":
        return counts.keybindings;
      case "mcp":
        return counts.mcpServers.user + counts.mcpServers.project;
      case "hooks":
        return Object.values(counts.hooks).reduce((a, b) => a + b, 0);
      case "settings":
        return counts.settingsFiles;
      case "memory":
        return counts.memory;
      default:
        return null;
    }
  };
  return (
    <ConfigTabBar
      tabs={TABS.map(({ key, icon, i18nKey, group }) => ({
        key,
        icon,
        label: t(i18nKey),
        count: countFor(key),
        group: group ? t(group) : undefined,
      }))}
      current={current}
      onSelect={onSelect}
      testIdPrefix="cc-tab"
      panelId="cc-tabpanel"
      ariaLabel={t("title")}
    />
  );
}

// ── Tab panel switch ──────────────────────────────────────────────────

interface TabPanelProps {
  tab: TabKey;
  data: PageState;
  search: string;
  onOpenFile: (path: string) => void;
  onEdit: (
    type: CcArtifactType,
    item: { scope: "user" | "project"; name: string; filePath: string }
  ) => void;
  onDelete: (
    type: CcArtifactType,
    scope: "user" | "project",
    name: string | undefined,
    path: string
  ) => void;
  onCreateMemory: (scope: "user" | "project") => void;
  onEditAuto: (item: CcMemoryItem) => void;
  onDeleteAuto: (item: CcMemoryItem) => void;
  onCreateAuto: (project: string) => void;
  /** Refetch every config surface after a mutation. */
  onChanged: () => void;
  onToast: (toast: NonNullable<Toast>) => void;
  /** An editor reports unsaved edits (by id), so a tab switch asks first. */
  onDirty: OnDirty;
}

function TabPanel({
  tab,
  data,
  search,
  onOpenFile,
  onEdit,
  onDelete,
  onCreateMemory,
  onEditAuto,
  onDeleteAuto,
  onCreateAuto,
  onChanged,
  onToast,
  onDirty,
}: TabPanelProps) {
  switch (tab) {
    case "overview":
      return <OverviewPanel overview={data.overview} />;
    case "skills":
      return (
        <MdItemList
          items={data.skills}
          search={search}
          onOpen={onOpenFile}
          onEdit={onEdit}
          onDelete={onDelete}
          kind="skills"
        />
      );
    case "agents":
      return (
        <MdItemList
          items={data.agents}
          search={search}
          onOpen={onOpenFile}
          onEdit={onEdit}
          onDelete={onDelete}
          kind="agents"
        />
      );
    case "commands":
      return (
        <MdItemList
          items={data.commands}
          search={search}
          onOpen={onOpenFile}
          onEdit={onEdit}
          onDelete={onDelete}
          kind="commands"
        />
      );
    case "outputStyles":
      return (
        <MdItemList
          items={data.outputStyles}
          search={search}
          onOpen={onOpenFile}
          onEdit={onEdit}
          onDelete={onDelete}
          kind="outputStyles"
        />
      );
    case "plugins":
      return (
        <PluginsPanel data={data.plugins} search={search} onToast={onToast} onChanged={onChanged} />
      );
    case "marketplaces":
      return (
        <MarketplacesPanel
          data={data.marketplaces}
          search={search}
          onToast={onToast}
          onChanged={onChanged}
        />
      );
    case "mcp":
      return (
        <McpPanel
          data={data.mcp}
          search={search}
          onToast={onToast}
          onChanged={onChanged}
          onDirty={onDirty}
        />
      );
    case "hooks":
      return (
        <HooksPanel
          sources={data.hooks}
          scripts={data.hookScripts}
          search={search}
          onOpen={onOpenFile}
          onToast={onToast}
          onChanged={onChanged}
          onDirty={onDirty}
        />
      );
    case "keybindings":
      return (
        <KeybindingsPanel
          data={data.keybindings}
          search={search}
          onSaved={onChanged}
          onToast={onToast}
          onDirty={onDirty}
        />
      );
    case "settings":
      return (
        <SettingsPanel
          sources={data.settings}
          statusline={data.statusline}
          onOpen={onOpenFile}
          onToast={onToast}
          onChanged={onChanged}
          onDirty={onDirty}
        />
      );
    case "memory":
      return (
        <MemoryPanel
          items={data.memory}
          search={search}
          onOpen={onOpenFile}
          onEdit={onEdit}
          onDelete={onDelete}
          onCreate={onCreateMemory}
          onEditAuto={onEditAuto}
          onDeleteAuto={onDeleteAuto}
          onCreateAuto={onCreateAuto}
        />
      );
    default:
      return null;
  }
}

// ── Overview ──────────────────────────────────────────────────────────

// Tone palette - each tone is { iconBg, iconText, border, accentBar }.
// Used by both root rows and summary stat tiles for a consistent color story.
type Tone =
  | "sky"
  | "emerald"
  | "violet"
  | "amber"
  | "fuchsia"
  | "cyan"
  | "pink"
  | "indigo"
  | "orange"
  | "teal"
  | "slate"
  | "rose";
const TONES: Record<Tone, { iconBg: string; iconText: string; bar: string; ring: string }> = {
  sky: {
    iconBg: "bg-sky-500/10",
    iconText: "text-sky-700 dark:text-sky-300",
    bar: "bg-sky-500/40",
    ring: "ring-sky-500/20",
  },
  emerald: {
    iconBg: "bg-status-success/10",
    iconText: "text-status-success",
    bar: "bg-status-success/40",
    ring: "ring-status-success/20",
  },
  violet: {
    iconBg: "bg-violet-500/10",
    iconText: "text-violet-700 dark:text-violet-300",
    bar: "bg-violet-500/40",
    ring: "ring-violet-500/20",
  },
  amber: {
    iconBg: "bg-status-warning/10",
    iconText: "text-status-warning",
    bar: "bg-status-warning/40",
    ring: "ring-status-warning/20",
  },
  fuchsia: {
    iconBg: "bg-fuchsia-500/10",
    iconText: "text-fuchsia-700 dark:text-fuchsia-300",
    bar: "bg-fuchsia-500/40",
    ring: "ring-fuchsia-500/20",
  },
  cyan: {
    iconBg: "bg-cyan-500/10",
    iconText: "text-cyan-700 dark:text-cyan-300",
    bar: "bg-cyan-500/40",
    ring: "ring-cyan-500/20",
  },
  pink: {
    iconBg: "bg-pink-500/10",
    iconText: "text-pink-700 dark:text-pink-300",
    bar: "bg-pink-500/40",
    ring: "ring-pink-500/20",
  },
  indigo: {
    iconBg: "bg-indigo-500/10",
    iconText: "text-indigo-700 dark:text-indigo-300",
    bar: "bg-indigo-500/40",
    ring: "ring-indigo-500/20",
  },
  orange: {
    iconBg: "bg-orange-500/10",
    iconText: "text-orange-700 dark:text-orange-300",
    bar: "bg-orange-500/40",
    ring: "ring-orange-500/20",
  },
  teal: {
    iconBg: "bg-teal-500/10",
    iconText: "text-teal-700 dark:text-teal-300",
    bar: "bg-teal-500/40",
    ring: "ring-teal-500/20",
  },
  slate: {
    iconBg: "bg-surface-4/10",
    iconText: "text-fg-secondary",
    bar: "bg-surface-4/40",
    ring: "ring-border-light/20",
  },
  rose: {
    iconBg: "bg-rose-500/10",
    iconText: "text-rose-700 dark:text-rose-300",
    bar: "bg-rose-500/40",
    ring: "ring-rose-500/20",
  },
};

function OverviewPanel({ overview }: { overview: CcOverview | null }) {
  const { t } = useTranslation("ccConfig");
  if (!overview) return <SkeletonRows n={4} />;
  const { roots, counts } = overview;
  return (
    <div className="space-y-5">
      <section>
        <h2 className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-2">
          {t("overview.rootsTitle")}
        </h2>
        <div className="grid grid-cols-1 md:grid-cols-2 gap-2">
          <RootRow
            icon={FolderTree}
            tone="emerald"
            label={t("overview.projectClaudeDir")}
            value={roots.projectClaudeDir}
          />
          <RootRow
            icon={FolderTree}
            tone="violet"
            label={t("overview.projectRoot")}
            value={roots.projectRoot}
          />
          <RootRow
            icon={FileText}
            tone="amber"
            label={t("overview.claudeJson")}
            value={roots.claudeJson}
          />
        </div>
      </section>

      <section>
        <h2 className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-2">
          {t("overview.summary")}
        </h2>
        <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-5 gap-2">
          <SummaryStat
            tone="fuchsia"
            icon={Sparkles}
            label={t("tabs.skills")}
            user={counts.skills.user}
            project={counts.skills.project}
          />
          <SummaryStat
            tone="sky"
            icon={UserRound}
            label={t("tabs.agents")}
            user={counts.agents.user}
            project={counts.agents.project}
          />
          <SummaryStat
            tone="cyan"
            icon={Slash}
            label={t("tabs.commands")}
            user={counts.commands.user}
            project={counts.commands.project}
          />
          <SummaryStat
            tone="pink"
            icon={Palette}
            label={t("tabs.outputStyles")}
            user={counts.outputStyles.user}
            project={counts.outputStyles.project}
          />
          <SummaryStat
            tone="indigo"
            icon={Server}
            label={t("tabs.mcp")}
            user={counts.mcpServers.user}
            project={counts.mcpServers.project}
          />
          <SummaryStat
            tone="emerald"
            icon={PlugZap}
            label={t("tabs.plugins")}
            value={counts.plugins}
          />
          <SummaryStat
            tone="amber"
            icon={Store}
            label={t("tabs.marketplaces")}
            value={counts.marketplaces}
          />
          <SummaryStat
            tone="orange"
            icon={Webhook}
            label={t("tabs.hooks")}
            value={Object.values(counts.hooks).reduce((a, b) => a + b, 0)}
          />
          <SummaryStat
            tone="rose"
            icon={Keyboard}
            label={t("tabs.keybindings")}
            value={counts.keybindings}
          />
          <SummaryStat
            tone="slate"
            icon={SettingsIcon}
            label={t("tabs.settings")}
            value={counts.settingsFiles}
          />
          <SummaryStat tone="teal" icon={BookOpen} label={t("tabs.memory")} value={counts.memory} />
        </div>
      </section>
    </div>
  );
}

interface SummaryStatProps {
  tone: Tone;
  icon: typeof Sparkles;
  label: string;
  // Either a single value, OR a user/project pair (which is summed for the headline number).
  value?: number;
  user?: number;
  project?: number;
}

function SummaryStat({ tone, icon: Icon, label, value, user, project }: SummaryStatProps) {
  const { t } = useTranslation("ccConfig");
  const T = TONES[tone];
  const total = value !== undefined ? value : (user ?? 0) + (project ?? 0);
  const showBreakdown = user !== undefined && project !== undefined;
  return (
    <div className={`relative rounded-lg border border-border bg-surface-2 overflow-hidden`}>
      {/* Left accent bar */}
      <div className={`absolute left-0 top-0 bottom-0 w-1 ${T.bar}`} aria-hidden />
      <div className="pl-3.5 pr-3 py-2.5">
        <div className="flex items-center gap-2">
          <span
            className={`w-6 h-6 rounded-md ${T.iconBg} flex items-center justify-center flex-shrink-0`}
          >
            <Icon className={`w-3.5 h-3.5 ${T.iconText}`} />
          </span>
          <span className="text-[10px] font-semibold uppercase tracking-wider text-fg-secondary truncate">
            {label}
          </span>
        </div>
        <div className="mt-1.5 flex items-baseline gap-2">
          <span className="text-xl font-semibold text-fg-primary tabular-nums">{total}</span>
          {showBreakdown && (
            <span className="text-[10px] text-fg-muted truncate">
              {user} {t("overview.user")} · {project} {t("overview.project")}
            </span>
          )}
        </div>
      </div>
    </div>
  );
}

function RootRow({
  icon: Icon,
  tone,
  label,
  value,
}: {
  icon: typeof FolderTree;
  tone: Tone;
  label: string;
  value: string;
}) {
  const T = TONES[tone];
  return (
    <div className="relative flex items-center gap-2.5 rounded-lg border border-border bg-surface-2 px-3 py-2 min-w-0 overflow-hidden">
      <div className={`absolute left-0 top-0 bottom-0 w-1 ${T.bar}`} aria-hidden />
      <span
        className={`w-7 h-7 rounded-md ${T.iconBg} flex items-center justify-center flex-shrink-0 ml-1.5`}
      >
        <Icon className={`w-3.5 h-3.5 ${T.iconText}`} />
      </span>
      <div className="min-w-0 flex-1">
        <div className="text-[10px] font-semibold uppercase tracking-wider text-fg-secondary">
          {label}
        </div>
        <div className="font-mono text-[11px] text-fg-secondary truncate">{value}</div>
      </div>
      <CopyButton value={value} />
    </div>
  );
}

// ── Plugins ───────────────────────────────────────────────────────────

/**
 * Shared runner for the `claude`-CLI-backed actions (plugins, marketplaces)
 * and the settings key-merge. Tracks which row is mid-flight so its buttons
 * can disable, and funnels both outcomes into the page's toast.
 */
function useConfigAction(onToast: (t: NonNullable<Toast>) => void, onChanged: () => void) {
  const [busy, setBusy] = useState<string | null>(null);
  const run = useCallback(
    async (id: string, fn: () => Promise<unknown>, successMessage: string) => {
      setBusy(id);
      try {
        await fn();
        onToast({ kind: "success", message: successMessage });
        onChanged();
        return true;
      } catch (err: unknown) {
        onToast({
          kind: "error",
          message: err instanceof Error ? err.message : "unknown error",
        });
        return false;
      } finally {
        setBusy(null);
      }
    },
    [onChanged, onToast]
  );
  return { busy, run };
}

/**
 * Does this look like a marketplace SOURCE (`owner/repo`, an http(s) URL, or an
 * absolute path) rather than a plugin spec (`name` / `name@marketplace`)? Lets
 * one input field accept either — pasting a GitHub link registers the
 * marketplace, typing a spec installs the plugin. The server re-validates; this
 * only decides which endpoint to call.
 */
function looksLikeMarketplaceSource(value: string): boolean {
  const v = value.trim();
  if (!v) return false;
  if (/^https?:\/\//i.test(v)) return true;
  if (v.startsWith("/")) return true;
  return /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/.test(v);
}

/** Small action button used across the plugin/marketplace cards. */
function ActionButton({
  onClick,
  disabled,
  danger,
  icon: Icon,
  children,
}: {
  onClick: () => void;
  disabled?: boolean;
  danger?: boolean;
  icon: typeof Sparkles;
  children: React.ReactNode;
}) {
  return (
    <button
      type="button"
      onClick={onClick}
      disabled={disabled}
      className={`h-7 text-[11px] font-medium px-2.5 rounded-md border inline-flex items-center gap-1.5 disabled:opacity-50 ${
        danger
          ? "border-status-danger/30 bg-status-danger/10 hover:bg-status-danger/20 text-status-danger"
          : "border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary"
      }`}
    >
      <Icon className="w-3 h-3" />
      {children}
    </button>
  );
}

/** Icon + colour per batch-step state. */
type StepLook = { Icon: typeof CheckCircle2; className: string };
const STEP_FALLBACK: StepLook = { Icon: MinusCircle, className: "text-fg-muted" };
const STEP_LOOK: Record<string, StepLook> = {
  running: { Icon: RefreshCw, className: "text-accent animate-spin" },
  ok: { Icon: CheckCircle2, className: "text-status-success" },
  failed: { Icon: XCircle, className: "text-status-error" },
  skipped: { Icon: MinusCircle, className: "text-fg-muted" },
};

/**
 * "Update all" + "Reload sessions" for the whole Claude Code install.
 *
 * The batch runs in a detached server-side worker and is followed by polling
 * rather than by the POST's response, because the last step restarts the
 * dashboard when AgentHub is itself a plugin install. Polling therefore has to
 * tolerate the server disappearing mid-batch: a failed poll is ignored and
 * retried, never rendered as an error, because the most likely cause is the
 * successful restart this button asked for.
 */
function UpdateAllCard({
  onToast,
  onChanged,
}: {
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
}) {
  const { t } = useTranslation("ccConfig");
  const [batch, setBatch] = useState<CcUpdateAllBatch | null>(null);
  const [starting, setStarting] = useState(false);
  const [reloading, setReloading] = useState(false);
  const running = batch?.status === "running";

  const poll = useCallback(async () => {
    try {
      const res = await api.ccConfig.updateAllStatus();
      setBatch(res.batch);
      return res.batch;
    } catch {
      // Server is down (very likely the AgentHub restart we triggered) — keep
      // the last known steps on screen and try again on the next tick.
      return undefined;
    }
  }, []);

  // Pick up a batch already in flight, including one started by the server we
  // were talking to BEFORE it restarted itself.
  useEffect(() => {
    void poll();
  }, [poll]);

  useEffect(() => {
    if (!running) return;
    const id = setInterval(() => void poll(), 2000);
    return () => clearInterval(id);
  }, [running, poll]);

  // Refresh the surrounding inventory once the batch stops moving, so version
  // numbers and install paths catch up without a manual reload.
  const prevStatus = useRef<string | undefined>(undefined);
  useEffect(() => {
    if (prevStatus.current === "running" && batch?.status !== "running") onChanged();
    prevStatus.current = batch?.status;
  }, [batch?.status, onChanged]);

  const start = useCallback(async () => {
    setStarting(true);
    try {
      const res = await api.ccConfig.updateAll();
      onToast({ kind: "success", message: t("updateAll.started", { count: res.planned }) });
      await poll();
    } catch (err: unknown) {
      onToast({
        kind: "error",
        message: err instanceof Error ? err.message : t("updateAll.failed"),
      });
    } finally {
      setStarting(false);
    }
  }, [onToast, poll, t]);

  const reloadOnly = useCallback(async () => {
    setReloading(true);
    try {
      const res = await api.ccConfig.reload();
      onToast({
        kind: "success",
        message:
          res.lanes_total > 0
            ? t("updateAll.reloaded", { count: res.lanes_total })
            : t("updateAll.reloadedNone"),
      });
    } catch (err: unknown) {
      onToast({
        kind: "error",
        message: err instanceof Error ? err.message : t("updateAll.failed"),
      });
    } finally {
      setReloading(false);
    }
  }, [onToast, t]);

  return (
    <div className="rounded-lg border border-border bg-surface-2 px-3 py-2.5">
      <div className="flex items-center gap-2 flex-wrap">
        <div className="text-[11px] font-semibold text-fg-secondary">{t("updateAll.title")}</div>
        <div className="ml-auto flex items-center gap-1.5">
          <button
            type="button"
            onClick={() => void reloadOnly()}
            disabled={reloading || running}
            className="h-8 text-[11px] font-medium px-3 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <RotateCw className={`w-3 h-3 ${reloading ? "animate-spin" : ""}`} />
            {t("updateAll.reloadButton")}
          </button>
          <button
            type="button"
            onClick={() => void start()}
            disabled={starting || running}
            className="h-8 text-[11px] font-medium px-3 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <ArrowUpCircle className="w-3 h-3" />
            {running || starting ? t("updateAll.working") : t("updateAll.button")}
          </button>
        </div>
      </div>
      <p className="mt-1.5 text-[10px] text-fg-muted leading-relaxed">{t("updateAll.help")}</p>

      {batch && (
        <div className="mt-2 space-y-1">
          {batch.steps.map((step) => {
            const look = STEP_LOOK[step.status] ?? STEP_FALLBACK;
            return (
              <div key={step.key} className="flex items-start gap-1.5 text-[11px]">
                <look.Icon className={`w-3 h-3 mt-0.5 shrink-0 ${look.className}`} />
                <span className="font-mono text-fg-secondary truncate">{step.label}</span>
                {step.note && <span className="text-fg-muted truncate">— {step.note}</span>}
                {step.error && (
                  <span className="text-status-error truncate" title={step.error}>
                    — {step.error}
                  </span>
                )}
                {step.key === "reload" && step.lanes_total !== undefined && (
                  <span className="text-fg-muted">
                    {t("updateAll.reloadedCount", { count: step.lanes_total })}
                  </span>
                )}
              </div>
            );
          })}
          {batch.status === "abandoned" && (
            <p className="text-[10px] text-status-warning">{t("updateAll.abandoned")}</p>
          )}
          {batch.bootstrap_error && (
            <p className="text-[10px] text-status-error">
              {t("updateAll.bootstrapFailed", { error: batch.bootstrap_error })}
            </p>
          )}
          {running && <p className="text-[10px] text-fg-muted">{t("updateAll.restartWarning")}</p>}
        </div>
      )}
    </div>
  );
}

function PluginsPanel({
  data,
  search,
  onToast,
  onChanged,
}: {
  data: CcPluginsResponse | null;
  search: string;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
}) {
  const { t } = useTranslation("ccConfig");
  const { busy, run } = useConfigAction(onToast, onChanged);
  const [input, setInput] = useState("");
  const [available, setAvailable] = useState<CcAvailablePlugin[] | null>(null);
  const [availableError, setAvailableError] = useState<string | null>(null);
  const availableCtx = useContextMenu<CcAvailablePlugin>();
  const install = (a: CcAvailablePlugin) =>
    void run(
      a.pluginId,
      () => api.ccConfig.installPlugin(a.pluginId),
      t("manage.installed", { name: a.pluginId })
    );

  // The available inventory comes from the CLI, which may not be installed —
  // a failure here is a normal state, not a page error.
  const loadAvailable = useCallback(async () => {
    try {
      const res = await api.ccConfig.pluginsAvailable();
      setAvailable(res.available);
      setAvailableError(null);
    } catch (err: unknown) {
      setAvailable([]);
      setAvailableError(err instanceof Error ? err.message : "unknown error");
    }
  }, []);

  useEffect(() => {
    void loadAvailable();
  }, [loadAvailable, data]);

  const submit = useCallback(async () => {
    const value = input.trim();
    if (!value) return;
    const isSource = looksLikeMarketplaceSource(value);
    const ok = await run(
      "add",
      () => (isSource ? api.ccConfig.addMarketplace(value) : api.ccConfig.installPlugin(value)),
      isSource
        ? t("manage.marketplaceAdded", { name: value })
        : t("manage.installed", { name: value })
    );
    if (ok) {
      setInput("");
      void loadAvailable();
    }
  }, [input, loadAvailable, run, t]);

  if (!data) return <SkeletonRows n={4} />;
  const needle = search.toLowerCase();
  const filtered = data.plugins.filter((p) => !search || p.key.toLowerCase().includes(needle));
  const installedKeys = new Set(data.plugins.map((p) => p.key));
  const installable = (available ?? []).filter(
    (a) =>
      !installedKeys.has(a.pluginId) &&
      (!search ||
        a.pluginId.toLowerCase().includes(needle) ||
        (a.description || "").toLowerCase().includes(needle))
  );

  return (
    <div className="space-y-3">
      <ExplainerBanner
        title={t("explain.plugins.title")}
        body={t("explain.plugins.body")}
        howTo={t("explain.plugins.install")}
        commands={[{ cmd: t("explain.plugins.installCmd"), note: "" }]}
      />

      <UpdateAllCard onToast={onToast} onChanged={onChanged} />

      <div className="rounded-lg border border-accent/25 bg-accent/5 px-3 py-2.5">
        <div className="text-[11px] font-semibold text-fg-secondary mb-1.5">
          {t("manage.installTitle")}
        </div>
        <div className="flex items-center gap-2 flex-wrap">
          <input
            value={input}
            onChange={(e) => setInput(e.target.value)}
            onKeyDown={(e) => {
              if (isSubmitEnter(e)) void submit();
            }}
            placeholder={t("manage.installPlaceholder")}
            aria-label={t("manage.installTitle")}
            className="h-8 flex-1 min-w-60 bg-surface-1 border border-border rounded px-2 text-[12px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
          />
          <button
            type="button"
            onClick={() => void submit()}
            disabled={!input.trim() || busy === "add"}
            className="h-8 text-[11px] font-medium px-3 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <Plus className="w-3 h-3" />
            {busy === "add" ? t("manage.working") : t("manage.installButton")}
          </button>
        </div>
        <p className="mt-1.5 text-[10px] text-fg-muted leading-relaxed">
          {t("manage.installHelp")}
        </p>
      </div>

      <div className="rounded-lg border border-border bg-surface-2 px-3 py-2 flex items-center gap-2 text-[11px] text-fg-muted">
        <FileText className="w-3.5 h-3.5" />
        <span className="font-mono truncate">{data.manifestPath}</span>
        {!data.manifestExists && (
          <span className="ml-auto text-status-warning">
            {t("plugins.manifestMissing", { path: "" })}
          </span>
        )}
      </div>

      {filtered.length === 0 ? (
        <Empty />
      ) : (
        filtered.map((p) => <PluginCard key={p.key} plugin={p} busy={busy} run={run} />)
      )}

      {installable.length > 0 && (
        <div>
          <h3 className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-2">
            {t("manage.availableTitle")}
          </h3>
          <div className="space-y-2">
            {installable.map((a) => (
              <div
                key={a.pluginId}
                onContextMenu={(e) => availableCtx.open(e, a)}
                className="rounded-lg border border-border bg-surface-2 px-4 py-2.5 flex items-start gap-3"
              >
                <div className="min-w-0 flex-1">
                  <div className="flex items-center gap-2 flex-wrap">
                    <span className="font-mono text-sm text-fg-primary">{a.name}</span>
                    {a.marketplaceName && (
                      <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border">
                        {a.marketplaceName}
                      </span>
                    )}
                  </div>
                  {a.description && (
                    <p className="mt-1 text-xs text-fg-secondary leading-relaxed line-clamp-2">
                      {a.description}
                    </p>
                  )}
                </div>
                <ActionButton icon={Plus} disabled={busy === a.pluginId} onClick={() => install(a)}>
                  {busy === a.pluginId ? t("manage.working") : t("manage.install")}
                </ActionButton>
              </div>
            ))}
          </div>
          {availableCtx.menu && (
            <ContextMenu
              x={availableCtx.menu.x}
              y={availableCtx.menu.y}
              onClose={availableCtx.close}
              testId="available-plugin-menu"
            >
              <MenuItem
                disabled={busy === availableCtx.menu.item.pluginId}
                onSelect={() => {
                  availableCtx.close();
                  install(availableCtx.menu!.item);
                }}
              >
                {t("manage.install")}
              </MenuItem>
              <MenuItem
                onSelect={() => {
                  availableCtx.close();
                  void copyText(availableCtx.menu!.item.pluginId);
                }}
              >
                {t("common.copyName")}
              </MenuItem>
            </ContextMenu>
          )}
        </div>
      )}

      {availableError && (
        <div className="rounded-md border border-status-warning/30 bg-status-warning/5 px-3 py-2 text-[11px] text-status-warning/90 flex items-center gap-2">
          <Info className="w-3.5 h-3.5 flex-shrink-0" />
          {t("manage.cliUnavailable", { message: availableError })}
        </div>
      )}
    </div>
  );
}

function PluginCard({
  plugin: p,
  busy,
  run,
}: {
  plugin: CcPlugin;
  busy: string | null;
  run: (id: string, fn: () => Promise<unknown>, message: string) => Promise<boolean>;
}) {
  const { t } = useTranslation("ccConfig");
  // Uninstall takes two clicks rather than a modal: the action is reversible
  // (reinstall), so an accidental single click is the only thing to guard.
  // useArmed: the armed state disarms by itself after 3 s, so a stray click
  // minutes later can never complete the uninstall.
  const uninstallArm = useArmed();
  const confirmUninstall = uninstallArm.isArmed("uninstall");
  const setConfirmUninstall = (on: boolean) =>
    on ? uninstallArm.arm("uninstall") : uninstallArm.disarm();
  // Which contribution surface is expanded, if any. One at a time: the card
  // sits in a list, and two open lists push everything below off the screen.
  const [openSurface, setOpenSurface] = useState<string | null>(null);
  const ctx = useContextMenu<true>();
  const toggle = () =>
    void run(
      p.key,
      () => api.ccConfig.pluginAction(p.key, p.enabled === false ? "enable" : "disable"),
      t(p.enabled === false ? "manage.enabled" : "manage.disabled", { name: p.key })
    );
  const update = () =>
    void run(
      p.key,
      // reload=true: updating one plugin reloads the open sessions
      // right away. The batch reloads once at the end instead.
      () => api.ccConfig.pluginAction(p.key, "update", true),
      t("manage.updated", { name: p.key })
    );
  const uninstall = () => {
    if (!confirmUninstall) {
      setConfirmUninstall(true);
      return;
    }
    setConfirmUninstall(false);
    void run(
      p.key,
      () => api.ccConfig.pluginAction(p.key, "uninstall"),
      t("manage.uninstalled", { name: p.key })
    );
  };
  const meta = p.contributes?.pluginJson;
  const description = meta?.description;
  const contribCounts: { key: string; count: number; label: string; items?: CcPluginItem[] }[] = [];
  if (p.contributes) {
    const items = p.contributes.items;
    if (p.contributes.skills > 0)
      contribCounts.push({
        key: "skills",
        count: p.contributes.skills,
        label: t("plugins.skills", { count: p.contributes.skills }),
        items: items?.skills,
      });
    if (p.contributes.agents > 0)
      contribCounts.push({
        key: "agents",
        count: p.contributes.agents,
        label: t("plugins.agents", { count: p.contributes.agents }),
        items: items?.agents,
      });
    if (p.contributes.commands > 0)
      contribCounts.push({
        key: "commands",
        count: p.contributes.commands,
        label: t("plugins.commands", { count: p.contributes.commands }),
        items: items?.commands,
      });
    if (p.contributes.outputStyles > 0)
      contribCounts.push({
        key: "outputStyles",
        count: p.contributes.outputStyles,
        label: t("plugins.outputStyles", { count: p.contributes.outputStyles }),
        items: items?.outputStyles,
      });
    // Hooks have no per-item list: a plugin's hooks are matcher/command pairs
    // declared inline in plugin.json, not addressable artifacts with names.
    if (p.contributes.hooks > 0)
      contribCounts.push({
        key: "hooks",
        count: p.contributes.hooks,
        label: t("plugins.hooks", { count: p.contributes.hooks }),
      });
  }
  const opened = contribCounts.find((c) => c.key === openSurface && c.items?.length);
  return (
    <div
      data-testid={`plugin-card-${p.key}`}
      onContextMenu={(e) => ctx.open(e, true)}
      className="rounded-lg border border-border bg-surface-2 px-4 py-3"
    >
      {ctx.menu && (
        <ContextMenu x={ctx.menu.x} y={ctx.menu.y} onClose={ctx.close} testId="plugin-menu">
          <MenuItem
            disabled={busy === p.key}
            onSelect={() => {
              ctx.close();
              toggle();
            }}
          >
            {p.enabled === false ? t("manage.enable") : t("manage.disable")}
          </MenuItem>
          <MenuItem
            disabled={busy === p.key}
            onSelect={() => {
              ctx.close();
              update();
            }}
          >
            {t("manage.update")}
          </MenuItem>
          <MenuItem
            onSelect={() => {
              ctx.close();
              void copyText(p.key);
            }}
          >
            {t("common.copyName")}
          </MenuItem>
          <MenuSeparator />
          <MenuItem
            danger
            disabled={busy === p.key}
            testId="plugin-menu-uninstall"
            // Two clicks here too: the first arms (the card's button shows
            // it), only the second uninstalls.
            onSelect={() => {
              if (confirmUninstall) ctx.close();
              uninstall();
            }}
          >
            {confirmUninstall ? t("manage.confirmUninstall") : t("manage.uninstall")}
          </MenuItem>
        </ContextMenu>
      )}
      <div className="flex items-start justify-between gap-3">
        <div className="min-w-0 flex-1">
          <div className="flex items-center gap-2 flex-wrap">
            <span className="font-mono text-sm text-fg-primary">{p.name}</span>
            {p.marketplace && (
              <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border">
                {p.marketplace}
              </span>
            )}
            {p.version && (
              <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-accent/10 text-accent border border-accent/20">
                v{p.version}
              </span>
            )}
            <ScopeBadge scope={p.scope} />
            {p.enabled === true && (
              <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-status-success/10 text-status-success border border-status-success/30 inline-flex items-center gap-1">
                <CircleDot className="w-3 h-3" />
                {t("plugins.enabled")}
              </span>
            )}
            {p.enabled === false && (
              <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-4/10 text-fg-secondary border border-border-light/30 inline-flex items-center gap-1">
                <CircleSlash className="w-3 h-3" />
                {t("plugins.disabled")}
              </span>
            )}
            {!p.installPathExists && (
              <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-status-warning/10 text-status-warning border border-status-warning/30 inline-flex items-center gap-1">
                <AlertCircle className="w-3 h-3" />
                {t("plugins.missing")}
              </span>
            )}
          </div>
          {description && (
            <p className="mt-1.5 text-xs text-fg-secondary leading-relaxed">{description}</p>
          )}
          {contribCounts.length > 0 && (
            <div className="mt-2.5">
              <div className="text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1">
                {t("plugins.contributes")}
              </div>
              <div className="flex flex-wrap gap-1.5">
                {contribCounts.map((c) =>
                  c.items?.length ? (
                    <button
                      key={c.key}
                      type="button"
                      aria-expanded={openSurface === c.key}
                      data-testid={`plugin-contrib-${p.key}-${c.key}`}
                      onClick={() => setOpenSurface((cur) => (cur === c.key ? null : c.key))}
                      className={`text-[10px] font-medium px-1.5 py-0.5 rounded border inline-flex items-center gap-1 transition-colors ${
                        openSurface === c.key
                          ? "bg-accent/10 text-accent border-accent/30"
                          : "bg-surface-3 text-fg-secondary border-border hover:border-border-light hover:text-fg-primary"
                      }`}
                    >
                      {c.label}
                      <ChevronDown
                        className={`w-2.5 h-2.5 transition-transform ${
                          openSurface === c.key ? "rotate-180" : ""
                        }`}
                      />
                    </button>
                  ) : (
                    <span
                      key={c.key}
                      className="text-[10px] font-medium px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border"
                    >
                      {c.label}
                    </span>
                  )
                )}
              </div>
              {opened && (
                <ul
                  data-testid={`plugin-contrib-list-${p.key}`}
                  className="mt-2 rounded border border-border bg-surface-1 divide-y divide-border"
                >
                  {opened.items?.map((item) => (
                    <li key={item.file} className="px-2.5 py-1.5">
                      <span className="font-mono text-[11px] text-fg-primary">
                        {opened.key === "commands" ? `/${item.name}` : item.name}
                      </span>
                      {item.description && (
                        <p className="mt-0.5 text-[11px] text-fg-muted leading-snug line-clamp-2">
                          {item.description}
                        </p>
                      )}
                    </li>
                  ))}
                </ul>
              )}
            </div>
          )}
          <div className="mt-2 grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-1 text-[11px] text-fg-muted">
            {meta?.author?.name && (
              <div>
                <span className="text-fg-muted">{t("plugins.author")}:</span> {meta.author.name}
              </div>
            )}
            {meta?.license && (
              <div>
                <span className="text-fg-muted">{t("plugins.license")}:</span> {meta.license}
              </div>
            )}
            {p.installedAt && (
              <div>
                <span className="text-fg-muted">{t("plugins.installedAt")}:</span>{" "}
                {new Date(p.installedAt).toLocaleString()}
              </div>
            )}
            {p.lastUpdated && (
              <div>
                <span className="text-fg-muted">{t("plugins.lastUpdated")}:</span>{" "}
                {new Date(p.lastUpdated).toLocaleString()}
              </div>
            )}
            {p.gitCommitSha && (
              <div className="col-span-2">
                <span className="text-fg-muted">SHA:</span>{" "}
                <span className="font-mono">{p.gitCommitSha.slice(0, 12)}</span>
              </div>
            )}
            {meta?.homepage && (
              <div className="col-span-2 truncate">
                <span className="text-fg-muted">{t("plugins.homepage")}:</span>{" "}
                <a
                  href={meta.homepage}
                  target="_blank"
                  rel="noopener noreferrer"
                  className="text-accent hover:underline"
                >
                  {meta.homepage}
                </a>
              </div>
            )}
          </div>
          {p.installPath && (
            <div className="mt-2 flex items-center gap-2">
              <span className="font-mono text-[10px] text-fg-muted truncate flex-1">
                {p.installPath}
              </span>
              <CopyButton value={p.installPath} />
            </div>
          )}
          <div className="mt-3 flex items-center gap-1.5 flex-wrap">
            {p.enabled === false ? (
              <ActionButton icon={CircleDot} disabled={busy === p.key} onClick={toggle}>
                {t("manage.enable")}
              </ActionButton>
            ) : (
              <ActionButton icon={CircleSlash} disabled={busy === p.key} onClick={toggle}>
                {t("manage.disable")}
              </ActionButton>
            )}
            <ActionButton icon={RefreshCw} disabled={busy === p.key} onClick={update}>
              {t("manage.update")}
            </ActionButton>
            <ActionButton icon={Trash2} danger disabled={busy === p.key} onClick={uninstall}>
              {busy === p.key
                ? t("manage.working")
                : confirmUninstall
                  ? t("manage.confirmUninstall")
                  : t("manage.uninstall")}
            </ActionButton>
          </div>
        </div>
      </div>
    </div>
  );
}

// ── MCP servers ───────────────────────────────────────────────────────

/** Splits a pasted command line on whitespace — good enough for the common
 *  `npx -y @scope/server --flag value` case. Skipped a full shell-arg
 *  parser (quoted args with embedded spaces won't survive); add one if a
 *  real server needs it. */
function splitCommandLine(value: string): [string, string[]] {
  const parts = value.trim().split(/\s+/).filter(Boolean);
  return [parts[0] || "", parts.slice(1)];
}

function McpPanel({
  data,
  search,
  onToast,
  onChanged,
  onDirty,
}: {
  data: CcMcpResponse | null;
  search: string;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  const { busy, run } = useConfigAction(onToast, onChanged);
  const [name, setName] = useState("");
  const [scope, setScope] = useState<CcMcpScope>("user");
  const [transport, setTransport] = useState<"stdio" | "http">("stdio");
  const [commandLine, setCommandLine] = useState("");
  const [url, setUrl] = useState("");
  useReportDirty("mcp:add", !!(name.trim() || commandLine.trim() || url.trim()), onDirty);

  const canSubmit =
    name.trim().length > 0 && (transport === "stdio" ? commandLine.trim() : url.trim());

  const submit = useCallback(async () => {
    const n = name.trim();
    if (!n) return;
    const args: CcMcpAddArgs =
      transport === "http"
        ? { name: n, scope, transport: "http", url: url.trim() }
        : (() => {
            const [command, cmdArgs] = splitCommandLine(commandLine);
            return { name: n, scope, command, args: cmdArgs };
          })();
    const ok = await run("add", () => api.ccConfig.mcpAdd(args), t("manage.mcpAdded", { name: n }));
    if (ok) {
      setName("");
      setCommandLine("");
      setUrl("");
    }
  }, [commandLine, name, run, scope, t, transport, url]);

  if (!data) return <SkeletonRows n={3} />;
  const all = [...data.user, ...data.projectScoped];
  const filter = (arr: CcMcpServer[]) =>
    arr.filter((s) => !search || s.name.toLowerCase().includes(search.toLowerCase()));

  return (
    <div className="space-y-4">
      <ExplainerBanner
        title={t("explain.mcp.title")}
        body={t("explain.mcp.body")}
        howTo={t("explain.mcp.add")}
        commands={[{ cmd: t("explain.mcp.listCmd"), note: t("explain.mcp.list") }]}
      />

      <div className="rounded-lg border border-accent/25 bg-accent/5 px-3 py-2.5 space-y-2">
        <div className="text-[11px] font-semibold text-fg-secondary">{t("manage.addMcpTitle")}</div>
        <div className="flex items-center gap-2 flex-wrap">
          <input
            value={name}
            onChange={(e) => setName(e.target.value)}
            placeholder={t("manage.addMcpNamePlaceholder")}
            aria-label={t("mcp.name")}
            className="h-8 w-40 bg-surface-1 border border-border rounded px-2 text-[12px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
          />
          <select
            value={scope}
            onChange={(e) => setScope(e.target.value as CcMcpScope)}
            aria-label={t("mcp.scope")}
            className="select h-8 py-0 text-[12px]"
          >
            <option value="user">{t("mcp.scopeUser")}</option>
            <option value="local">{t("mcp.scopeLocal")}</option>
          </select>
          <div className="flex rounded-md border border-border overflow-hidden">
            {(["stdio", "http"] as const).map((k) => (
              <button
                key={k}
                type="button"
                aria-pressed={transport === k}
                onClick={() => setTransport(k)}
                className={`h-8 px-2.5 text-[11px] font-medium ${
                  transport === k
                    ? "bg-accent/20 text-accent"
                    : "bg-surface-1 text-fg-secondary hover:bg-surface-3"
                }`}
              >
                {k === "stdio" ? t("manage.addMcpTransportStdio") : t("manage.addMcpTransportHttp")}
              </button>
            ))}
          </div>
        </div>
        {transport === "stdio" ? (
          <input
            value={commandLine}
            onChange={(e) => setCommandLine(e.target.value)}
            onKeyDown={(e) => {
              if (isSubmitEnter(e)) void submit();
            }}
            placeholder={t("manage.addMcpCommandPlaceholder")}
            aria-label={t("mcp.command")}
            className="h-8 w-full bg-surface-1 border border-border rounded px-2 text-[12px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
          />
        ) : (
          <input
            value={url}
            onChange={(e) => setUrl(e.target.value)}
            onKeyDown={(e) => {
              if (isSubmitEnter(e)) void submit();
            }}
            placeholder={t("manage.addMcpUrlPlaceholder")}
            aria-label={t("mcp.url")}
            className="h-8 w-full bg-surface-1 border border-border rounded px-2 text-[12px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
          />
        )}
        <div className="flex items-center justify-between">
          <p className="text-[10px] text-fg-muted leading-relaxed">{t("manage.addMcpHelp")}</p>
          <button
            type="button"
            onClick={() => void submit()}
            disabled={!canSubmit || busy === "add"}
            className="h-8 shrink-0 text-[11px] font-medium px-3 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <Plus className="w-3 h-3" />
            {busy === "add" ? t("manage.working") : t("manage.addMcpButton")}
          </button>
        </div>
      </div>

      {all.length === 0 && (
        <div className="rounded-lg border border-border bg-surface-2 px-4 py-6 text-center text-sm text-fg-muted">
          {t("mcp.noServers")}
        </div>
      )}
      {data.user.length > 0 && (
        <div>
          <h3 className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-2">
            {t("mcp.userScope")}
          </h3>
          <div className="space-y-2">
            {filter(data.user).map((s) => (
              <McpCard
                key={`u:${s.name}:${s.source}`}
                server={s}
                scope="user"
                run={run}
                busy={busy}
                t={t}
              />
            ))}
          </div>
        </div>
      )}
      {data.projectScoped.length > 0 && (
        <div>
          <h3 className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-2">
            {t("mcp.projectScope")}
          </h3>
          <div className="space-y-2">
            {filter(data.projectScoped).map((s) => (
              <McpCard
                key={`p:${s.name}:${s.source}`}
                server={s}
                scope="local"
                run={run}
                busy={busy}
                t={t}
              />
            ))}
          </div>
        </div>
      )}
    </div>
  );
}

function McpCard({
  server,
  scope,
  run,
  busy,
  t,
}: {
  server: CcMcpServer;
  scope: CcMcpScope;
  run: (id: string, fn: () => Promise<unknown>, successMessage: string) => Promise<boolean>;
  busy: string | null;
  t: (key: string, opts?: Record<string, unknown>) => string;
}) {
  const removeArm = useArmed();
  const confirmRemove = removeArm.isArmed("remove");
  const setConfirmRemove = (on: boolean) => (on ? removeArm.arm("remove") : removeArm.disarm());
  const ctx = useContextMenu<true>();
  const busyId = `${scope}:${server.name}`;
  // The reader decides this: entries from ~/.claude/settings.json have no CLI
  // scope that addresses them, so a Remove button would look live and never
  // work. Reading it off a flag rather than matching `source` keeps a reworded
  // display string from silently bringing that button back.
  const removable = server.removable !== false;
  const remove = () => {
    if (!confirmRemove) {
      setConfirmRemove(true);
      return;
    }
    setConfirmRemove(false);
    void run(
      busyId,
      () => api.ccConfig.mcpRemove(server.name, scope),
      t("manage.mcpRemoved", { name: server.name })
    );
  };
  return (
    <div
      onContextMenu={(e) => ctx.open(e, true)}
      className="rounded-lg border border-border bg-surface-2 px-4 py-3"
    >
      {ctx.menu && (
        <ContextMenu x={ctx.menu.x} y={ctx.menu.y} onClose={ctx.close} testId="mcp-menu">
          <MenuItem
            onSelect={() => {
              ctx.close();
              void copyText(server.name);
            }}
          >
            {t("common.copyName")}
          </MenuItem>
          {removable && (
            <>
              <MenuSeparator />
              <MenuItem
                danger
                disabled={busy === busyId}
                // Two clicks, like the card's Remove button.
                onSelect={() => {
                  if (confirmRemove) ctx.close();
                  remove();
                }}
              >
                {confirmRemove ? t("manage.confirmRemove") : t("manage.remove")}
              </MenuItem>
            </>
          )}
        </ContextMenu>
      )}
      <div className="flex items-center gap-2 flex-wrap">
        <span className="font-mono text-sm text-fg-primary">{server.name}</span>
        <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border">
          {server.kind}
        </span>
        <span className="text-[10px] text-fg-muted ml-auto truncate max-w-xs">{server.source}</span>
      </div>
      <div className="mt-2 space-y-1 text-[11px]">
        {server.kind === "stdio" && (
          <>
            <Field label={t("mcp.command")}>
              <span className="font-mono text-fg-secondary">{server.command}</span>
            </Field>
            {server.args && server.args.length > 0 && (
              <Field label={t("mcp.args")}>
                <span className="font-mono text-fg-secondary">{server.args.join(" ")}</span>
              </Field>
            )}
            {server.envNames && server.envNames.length > 0 && (
              <Field label={t("mcp.env")}>
                <span className="font-mono text-fg-secondary">{server.envNames.join(", ")}</span>
              </Field>
            )}
          </>
        )}
        {server.kind === "http" && (
          <>
            <Field label={t("mcp.url")}>
              <span className="font-mono text-fg-secondary">{server.url}</span>
            </Field>
            {server.headers && server.headers.length > 0 && (
              <Field label={t("mcp.headers")}>
                <span className="font-mono text-fg-secondary">{server.headers.join(", ")}</span>
              </Field>
            )}
          </>
        )}
      </div>
      <div className="mt-3">
        {removable ? (
          <ActionButton icon={Trash2} danger disabled={busy === busyId} onClick={remove}>
            {busy === busyId
              ? t("manage.working")
              : confirmRemove
                ? t("manage.confirmRemove")
                : t("manage.remove")}
          </ActionButton>
        ) : (
          <p className="text-[10px] text-fg-muted">{t("mcp.notRemovable")}</p>
        )}
      </div>
    </div>
  );
}

function Field({ label, children }: { label: string; children: React.ReactNode }) {
  return (
    <div className="flex gap-2">
      <span className="text-fg-muted min-w-20">{label}:</span>
      <span className="min-w-0 flex-1 truncate">{children}</span>
    </div>
  );
}

// ── Hooks ─────────────────────────────────────────────────────────────

/**
 * `readHooks` FLATTENS settings.json's `[{matcher, hooks:[…]}]` into one row
 * per command; this rebuilds the nested shape the file actually stores,
 * regrouping consecutive rows that share a matcher. Rows the editor never
 * created (an unknown event's raw objects) are filtered out upstream — those
 * events are simply never sent, so they stay untouched on disk.
 */
function toNestedHooks(entries: CcHookEntry[]): unknown[] {
  const groups: { matcher: string; hooks: Record<string, unknown>[] }[] = [];
  for (const e of entries) {
    const matcher = e.matcher || "*";
    let group = groups.find((g) => g.matcher === matcher);
    if (!group) {
      group = { matcher, hooks: [] };
      groups.push(group);
    }
    const hook: Record<string, unknown> = {
      type: e.type || "command",
      command: e.command || "",
    };
    if (e.timeout != null) hook.timeout = e.timeout;
    group.hooks.push(hook);
  }
  return groups;
}

/** A hook row the editor can round-trip — i.e. one `readHooks` flattened. */
function isEditableHookEntry(entry: unknown): entry is CcHookEntry {
  return !!entry && typeof entry === "object" && "command" in (entry as object);
}

function HooksPanel({
  sources,
  scripts,
  search,
  onOpen,
  onToast,
  onChanged,
  onDirty,
}: {
  sources: CcHookSource[] | null;
  scripts: CcHookScripts | null;
  search: string;
  onOpen: (p: string) => void;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  if (!sources) return <SkeletonRows n={3} />;
  return (
    <div className="space-y-4">
      <ExplainerBanner
        title={t("explain.hooks.title")}
        body={t("explain.hooks.body")}
        howTo={t("explain.hooks.howTo")}
        commands={[
          { cmd: t("explain.hooks.cmd1"), note: t("explain.hooks.cmd1Note") },
          { cmd: t("explain.hooks.cmd2"), note: t("explain.hooks.cmd2Note") },
          { cmd: t("explain.hooks.cmd3"), note: t("explain.hooks.cmd3Note") },
        ]}
      />
      {sources.map((src) => (
        <HookSourceBlock
          key={src.scope}
          source={src}
          search={search}
          onOpen={onOpen}
          onToast={onToast}
          onChanged={onChanged}
          onDirty={onDirty}
        />
      ))}

      {scripts && scripts.items.length > 0 && (
        <div className="rounded-lg border border-border bg-surface-2">
          <div className="border-b border-border px-4 py-2.5">
            <div className="text-sm font-medium text-fg-primary">{t("hookScripts.title")}</div>
            <p className="mt-1 text-[11px] text-fg-muted leading-relaxed">
              {t("hookScripts.subtitle")}
            </p>
            <div className="mt-1 font-mono text-[10px] text-fg-muted">{scripts.dir}</div>
          </div>
          <div className="p-3 space-y-1.5">
            {scripts.items.map((s) => (
              <button
                key={s.file}
                onClick={() => onOpen(s.file)}
                className="w-full text-left rounded-md border border-border bg-surface-1 hover:bg-surface-3 px-3 py-1.5 inline-flex items-center gap-2"
              >
                <FileText className="w-3 h-3 text-fg-muted flex-shrink-0" />
                <span className="font-mono text-[11px] text-fg-secondary flex-1 truncate">
                  {s.name}
                </span>
                <span className="text-[10px] text-fg-muted">{formatBytes(s.size)}</span>
                <span className="text-[10px] text-fg-muted hidden md:inline">
                  {new Date(s.mtime).toLocaleDateString()}
                </span>
              </button>
            ))}
          </div>
        </div>
      )}
    </div>
  );
}

/**
 * One settings layer's hooks, readable and editable. Saving writes ONLY the
 * `hooks.<Event>` keys this editor owns, through `PATCH /settings`'s key
 * merge — every other key in the file, and every event whose entries the
 * editor could not parse, is left exactly as it was.
 */
function HookSourceBlock({
  source: src,
  search,
  onOpen,
  onToast,
  onChanged,
  onDirty,
}: {
  source: CcHookSource;
  search: string;
  onOpen: (p: string) => void;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  const { busy, run } = useConfigAction(onToast, onChanged);
  const [draft, setDraft] = useState<{ event: string; entries: CcHookEntry[] }[] | null>(null);
  const [err, setErr] = useState<string | null>(null);
  // Snapshot taken at Edit: the events this editor owns and the file's hooks
  // as they were. Save unsets only events from THIS snapshot, so an event
  // written meanwhile (a session, a terminal) is never deleted.
  const base = useRef<{ events: string[]; hooks: string; draft: string } | null>(null);
  const dirty = draft !== null && JSON.stringify(draft) !== base.current?.draft;
  useReportDirty(`hooks:${src.scope}`, dirty, onDirty);

  const editableEvents = useMemo(
    () =>
      Object.entries(src.hooks).filter(([, entries]) =>
        (entries as unknown[]).every(isEditableHookEntry)
      ),
    [src.hooks]
  );
  const readOnlyEvents = useMemo(
    () =>
      Object.entries(src.hooks).filter(
        ([, entries]) => !(entries as unknown[]).every(isEditableHookEntry)
      ),
    [src.hooks]
  );

  const startEdit = () => {
    setErr(null);
    const next = editableEvents.map(([event, entries]) => ({
      event,
      entries: entries.map((e) => ({ ...e })),
    }));
    base.current = {
      events: editableEvents.map(([event]) => event),
      hooks: JSON.stringify(src.hooks),
      draft: JSON.stringify(next),
    };
    setDraft(next);
  };

  const save = async () => {
    if (!draft) return;
    const set: Record<string, unknown> = {};
    const seen = new Set<string>();
    for (const { event, entries } of draft) {
      const name = event.trim();
      if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(name)) {
        setErr(t("manage.hookBadEvent", { event: event || "-" }));
        return;
      }
      if (seen.has(name)) {
        setErr(t("manage.hookDupEvent", { event: name }));
        return;
      }
      // An event the editor could not parse is left on disk untouched; a new
      // row with its name would replace those entries.
      if (readOnlyEvents.some(([e]) => e === name)) {
        setErr(t("manage.hookReadOnlyEvent", { event: name }));
        return;
      }
      seen.add(name);
      if (entries.some((e) => !e.command || !e.command.trim())) {
        setErr(t("manage.hookEmptyCommand", { event: name }));
        return;
      }
      set[`hooks.${name}`] = toNestedHooks(entries);
    }
    // An event dropped from the draft is removed from the file; one that was
    // never editable here — or appeared after Edit — is never touched.
    const unset = (base.current?.events ?? [])
      .filter((event) => !seen.has(event))
      .map((event) => `hooks.${event}`);
    if (
      base.current &&
      JSON.stringify(src.hooks) !== base.current.hooks &&
      !(await confirmDialog({
        title: t("edit.changedOnDiskTitle"),
        message: t("manage.hooksChangedBody"),
        confirmLabel: t("edit.overwrite"),
      }))
    )
      return;

    setErr(null);
    const ok = await run(
      "save",
      () =>
        api.ccConfig.patchSettings({
          scope: src.scope,
          set,
          ...(unset.length ? { unset } : {}),
        }),
      t("manage.hooksSaved", { file: src.file })
    );
    if (ok) setDraft(null);
  };

  const updateEntry = (ei: number, hi: number, field: keyof CcHookEntry, value: string) =>
    setDraft((d) =>
      d
        ? d.map((g, i) =>
            i === ei
              ? {
                  ...g,
                  entries: g.entries.map((h, j) =>
                    j === hi
                      ? {
                          ...h,
                          [field]: field === "timeout" ? (value ? Number(value) : null) : value,
                        }
                      : h
                  ),
                }
              : g
          )
        : d
    );

  const filteredEvents = search
    ? Object.entries(src.hooks).filter(([event]) =>
        event.toLowerCase().includes(search.toLowerCase())
      )
    : Object.entries(src.hooks);

  return (
    <div className="rounded-lg border border-border bg-surface-2">
      <div className="border-b border-border px-4 py-2.5 flex items-center gap-2 flex-wrap">
        <ScopeBadge scope={src.scope} />
        <span className="font-mono text-[11px] text-fg-muted truncate flex-1 min-w-0">
          {src.file}
        </span>
        {src.exists ? (
          <button
            onClick={() => onOpen(src.file)}
            className="text-[11px] font-medium px-2 py-1 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1.5"
          >
            <ExternalLink className="w-3 h-3" />
            {t("common.viewSource")}
          </button>
        ) : (
          <span className="text-[11px] text-fg-muted">{t("hooks.fileMissing")}</span>
        )}
        {draft ? (
          <div className="inline-flex items-center gap-1.5">
            <ActionButton
              icon={X}
              onClick={async () => {
                if (dirty && !(await confirmDiscard())) return;
                setDraft(null);
              }}
              disabled={busy === "save"}
            >
              {t("edit.cancel")}
            </ActionButton>
            <ActionButton icon={Save} onClick={() => void save()} disabled={busy === "save"}>
              {busy === "save" ? t("edit.saving") : t("edit.save")}
            </ActionButton>
          </div>
        ) : (
          <ActionButton icon={Pencil} onClick={startEdit}>
            {t("edit.editButton")}
          </ActionButton>
        )}
      </div>

      {err && (
        <div className="mx-3 mt-3 rounded-lg border border-status-danger/40 bg-status-danger/10 px-3 py-2 text-[11px] text-status-danger flex items-center gap-2">
          <AlertCircle className="w-3.5 h-3.5 flex-shrink-0" />
          <span>{err}</span>
        </div>
      )}

      {draft ? (
        <div className="p-3 space-y-3">
          {draft.map((g, ei) => (
            <div key={ei} className="rounded-md border border-border bg-surface-1">
              <div className="border-b border-border px-2.5 py-1.5 flex items-center gap-2">
                <Wrench className="w-3 h-3 text-fg-muted flex-shrink-0" />
                <input
                  value={g.event}
                  onChange={(e) =>
                    setDraft((d) =>
                      d ? d.map((x, i) => (i === ei ? { ...x, event: e.target.value } : x)) : d
                    )
                  }
                  placeholder={t("manage.hookEvent")}
                  aria-label={t("manage.hookEvent")}
                  className="h-7 flex-1 min-w-0 bg-surface-2 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                />
                <button
                  type="button"
                  onClick={() => setDraft((d) => (d ? d.filter((_, i) => i !== ei) : d))}
                  title={t("manage.hookRemoveEvent")}
                  aria-label={t("manage.hookRemoveEvent")}
                  className="h-7 w-7 flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-status-danger hover:bg-status-danger/10"
                >
                  <Trash2 className="w-3.5 h-3.5" />
                </button>
              </div>
              <div className="divide-y divide-border">
                {g.entries.map((h, hi) => (
                  <div key={hi} className="px-2.5 py-2 space-y-1.5">
                    <div className="flex items-center gap-2">
                      <input
                        value={h.matcher || ""}
                        onChange={(e) => updateEntry(ei, hi, "matcher", e.target.value)}
                        placeholder={t("hooks.matcher")}
                        aria-label={t("hooks.matcher")}
                        className="h-7 w-32 flex-shrink-0 bg-surface-2 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                      />
                      <input
                        value={h.timeout == null ? "" : String(h.timeout)}
                        onChange={(e) => updateEntry(ei, hi, "timeout", e.target.value)}
                        placeholder={t("hooks.timeout")}
                        aria-label={t("hooks.timeout")}
                        inputMode="numeric"
                        className="h-7 w-24 flex-shrink-0 bg-surface-2 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                      />
                      <button
                        type="button"
                        onClick={() =>
                          setDraft((d) =>
                            d
                              ? d.map((x, i) =>
                                  i === ei
                                    ? { ...x, entries: x.entries.filter((_, j) => j !== hi) }
                                    : x
                                )
                              : d
                          )
                        }
                        title={t("manage.hookRemoveEntry")}
                        aria-label={t("manage.hookRemoveEntry")}
                        className="h-7 w-7 ml-auto flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-status-danger hover:bg-status-danger/10"
                      >
                        <Trash2 className="w-3.5 h-3.5" />
                      </button>
                    </div>
                    <input
                      value={h.command || ""}
                      onChange={(e) => updateEntry(ei, hi, "command", e.target.value)}
                      placeholder={t("hooks.command")}
                      aria-label={t("hooks.command")}
                      className="h-7 w-full bg-surface-2 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                    />
                  </div>
                ))}
                <div className="px-2.5 py-1.5">
                  <ActionButton
                    icon={Plus}
                    onClick={() =>
                      setDraft((d) =>
                        d
                          ? d.map((x, i) =>
                              i === ei
                                ? {
                                    ...x,
                                    entries: [
                                      ...x.entries,
                                      { matcher: "*", type: "command", command: "", timeout: null },
                                    ],
                                  }
                                : x
                            )
                          : d
                      )
                    }
                  >
                    {t("manage.hookAddEntry")}
                  </ActionButton>
                </div>
              </div>
            </div>
          ))}
          <button
            type="button"
            onClick={() =>
              setDraft((d) => [
                ...(d ?? []),
                {
                  event: "",
                  entries: [{ matcher: "*", type: "command", command: "", timeout: null }],
                },
              ])
            }
            className="h-8 w-full text-[11px] font-medium rounded-md border border-dashed border-border bg-surface-2 hover:bg-surface-3 text-fg-secondary inline-flex items-center justify-center gap-1.5"
          >
            <Plus className="w-3 h-3" />
            {t("manage.hookAddEvent")}
          </button>
          {readOnlyEvents.length > 0 && (
            <p className="text-[10px] text-fg-muted leading-relaxed">
              {t("manage.hookUneditable", {
                events: readOnlyEvents.map(([e]) => e).join(", "),
              })}
            </p>
          )}
        </div>
      ) : (
        <div className="p-3">
          {filteredEvents.length === 0 ? (
            <div className="text-xs text-fg-muted px-1 py-2">{t("hooks.noHooks")}</div>
          ) : (
            <div className="space-y-3">
              {filteredEvents.map(([event, entries]) => (
                <div key={event}>
                  <div className="text-[11px] font-semibold text-fg-secondary mb-1.5 inline-flex items-center gap-2">
                    <Wrench className="w-3 h-3 text-fg-muted" />
                    {event}
                    <span className="text-[10px] text-fg-muted">({entries.length})</span>
                  </div>
                  <div className="space-y-1.5 pl-5">
                    {entries.map((h, idx) => (
                      <div
                        key={`${event}-${idx}`}
                        className="rounded-md border border-border bg-surface-1 px-2.5 py-1.5 text-[11px]"
                      >
                        <div className="flex items-center gap-2">
                          <span className="font-mono text-[10px] text-fg-muted">
                            {t("hooks.matcher")}={h.matcher}
                          </span>
                          <span className="text-[10px] text-fg-muted">·</span>
                          <span className="font-mono text-[10px] text-fg-muted">{h.type}</span>
                          {h.timeout != null && (
                            <span className="text-[10px] text-fg-muted">{h.timeout}ms</span>
                          )}
                        </div>
                        {h.command && (
                          <div className="mt-1 font-mono text-[11px] text-fg-secondary break-all">
                            {h.command}
                          </div>
                        )}
                      </div>
                    ))}
                  </div>
                </div>
              ))}
            </div>
          )}
        </div>
      )}
    </div>
  );
}

// ── Settings ──────────────────────────────────────────────────────────

// The settings that the TUI's `/config` editor manages, in display order.
// Surfaced as a resolved at-a-glance summary so the user sees what `/config`
// set (model, verbose, theme, …) without hunting through the raw JSON files.
// Keys map 1:1 to settings.json keys per https://code.claude.com/docs/en/settings.
const CONFIG_OPTION_GROUPS: { title: string; keys: { key: string; label: string }[] }[] = [
  {
    title: "model",
    keys: [
      { key: "model", label: "Model" },
      { key: "effortLevel", label: "Effort level" },
      { key: "alwaysThinkingEnabled", label: "Always thinking" },
    ],
  },
  {
    title: "output",
    keys: [
      { key: "outputStyle", label: "Output style" },
      { key: "verbose", label: "Verbose output" },
      { key: "theme", label: "Theme" },
      { key: "language", label: "Language" },
      { key: "spinnerTipsEnabled", label: "Spinner tips" },
      { key: "autoScrollEnabled", label: "Auto-scroll" },
    ],
  },
  {
    title: "session",
    keys: [
      { key: "autoCompactEnabled", label: "Auto-compact" },
      { key: "fileCheckpointingEnabled", label: "File checkpointing" },
      { key: "editorMode", label: "Editor mode" },
      { key: "preferredNotifChannel", label: "Notifications" },
      { key: "awaySummaryEnabled", label: "Away summary" },
    ],
  },
];

/**
 * Resolve each /config option across the settings sources (project-local >
 * project > user precedence - later sources in the array win) and render a
 * compact summary. Unset options show as "default" so the view reflects the
 * effective configuration, not just whatever happens to be written to a file.
 */
function CurrentConfigPanel({ sources }: { sources: CcSettingsSource[] }) {
  const { t } = useTranslation("ccConfig");
  // Build effective map: { key → { value, scope } }. Sources arrive ordered
  // user → project → project-local, so a later hit overrides an earlier one.
  const effective = new Map<string, { value: unknown; scope: CcSettingsSource["scope"] }>();
  for (const src of sources) {
    if (!src.exists || !src.data || typeof src.data !== "object") continue;
    const data = src.data as Record<string, unknown>;
    for (const group of CONFIG_OPTION_GROUPS) {
      for (const { key } of group.keys) {
        if (Object.prototype.hasOwnProperty.call(data, key)) {
          effective.set(key, { value: data[key], scope: src.scope });
        }
      }
    }
  }
  const setCount = effective.size;

  return (
    <div className="rounded-lg border border-border bg-surface-2">
      <div className="border-b border-border px-4 py-2.5 flex items-center gap-2">
        <SettingsIcon className="w-3.5 h-3.5 text-violet-700/80 dark:text-violet-300/80" />
        <span className="text-sm font-medium text-fg-primary">{t("currentConfig.title")}</span>
        <span className="text-[11px] text-fg-muted ml-auto">
          {t("currentConfig.setCount", { count: setCount })}
        </span>
      </div>
      <div className="p-3 space-y-3">
        {CONFIG_OPTION_GROUPS.map((group) => (
          <div key={group.title}>
            <div className="text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5">
              {t(`currentConfig.groups.${group.title}`)}
            </div>
            <div className="rounded-md border border-border bg-surface-1 divide-y divide-border">
              {group.keys.map(({ key, label }) => {
                const hit = effective.get(key);
                return (
                  <div
                    key={key}
                    className="px-3 py-1.5 grid grid-cols-[150px_1fr_auto] gap-3 items-center"
                  >
                    <div className="text-[11px] text-fg-secondary truncate" title={key}>
                      {t(`currentConfig.keys.${key}`, { defaultValue: label })}
                    </div>
                    <div className="min-w-0">
                      {hit ? (
                        <SettingsValue value={hit.value} />
                      ) : (
                        <span className="text-[10px] text-fg-muted italic">
                          {t("currentConfig.default")}
                        </span>
                      )}
                    </div>
                    {hit ? (
                      <ScopeBadge scope={hit.scope} />
                    ) : (
                      <span className="text-[10px] text-fg-muted">-</span>
                    )}
                  </div>
                );
              })}
            </div>
          </div>
        ))}
      </div>
    </div>
  );
}

function SettingsPanel({
  sources,
  statusline,
  onOpen,
  onToast,
  onChanged,
  onDirty,
}: {
  sources: CcSettingsSource[] | null;
  statusline: CcStatusline | null;
  onOpen: (p: string) => void;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  if (!sources) return <SkeletonRows n={3} />;
  return (
    <div className="space-y-3">
      <ExplainerBanner
        title={t("explain.settings.title")}
        body={t("explain.settings.body")}
        howTo={t("explain.settings.howTo")}
        commands={[
          { cmd: t("explain.settings.cmd1"), note: t("explain.settings.cmd1Note") },
          { cmd: t("explain.settings.cmd2"), note: t("explain.settings.cmd2Note") },
          { cmd: t("explain.settings.cmd3"), note: t("explain.settings.cmd3Note") },
        ]}
      />
      <CurrentConfigPanel sources={sources} />
      <div className="rounded-md border border-status-warning/30 bg-status-warning/5 px-3 py-2 text-[11px] text-status-warning/90 flex items-center gap-2">
        <Info className="w-3.5 h-3.5 flex-shrink-0" />
        {t("common.redactedNotice")}
      </div>
      {statusline && (statusline.config || statusline.scripts.length > 0) && (
        <StatuslineBlock data={statusline} onOpen={onOpen} />
      )}
      {sources.map((src) => (
        <SettingsBlock
          key={src.scope}
          source={src}
          onOpen={onOpen}
          onToast={onToast}
          onChanged={onChanged}
          onDirty={onDirty}
        />
      ))}
    </div>
  );
}

function StatuslineBlock({ data, onOpen }: { data: CcStatusline; onOpen: (p: string) => void }) {
  const { t } = useTranslation("ccConfig");
  return (
    <div className="rounded-lg border border-border bg-surface-2">
      <div className="border-b border-border px-4 py-2.5">
        <div className="text-sm font-medium text-fg-primary">{t("statusline.title")}</div>
      </div>
      <div className="p-3 space-y-3">
        {data.config ? (
          <div>
            <div className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5">
              {t("statusline.configured")}
            </div>
            <div className="rounded-md border border-border bg-surface-1 px-3 py-2 text-[11px] font-mono text-fg-secondary">
              <span className="text-fg-muted">type:</span> {data.config.type ?? "-"}
              {data.config.command && (
                <>
                  <br />
                  <span className="text-fg-muted">command:</span> {data.config.command}
                </>
              )}
            </div>
          </div>
        ) : (
          <div className="text-xs text-fg-muted">{t("statusline.noStatusline")}</div>
        )}
        {data.scripts.length > 0 && (
          <div>
            <div className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5">
              {t("statusline.scripts")}
            </div>
            <div className="space-y-1.5">
              {data.scripts.map((s) => (
                <button
                  key={s.file}
                  onClick={() => onOpen(s.file)}
                  className="w-full text-left rounded-md border border-border bg-surface-1 hover:bg-surface-3 px-3 py-1.5 inline-flex items-center gap-2"
                >
                  <FileText className="w-3 h-3 text-fg-muted flex-shrink-0" />
                  <span className="font-mono text-[11px] text-fg-secondary flex-1 truncate">
                    {s.file}
                  </span>
                  <span className="text-[10px] text-fg-muted">{formatBytes(s.size)}</span>
                </button>
              ))}
            </div>
          </div>
        )}
      </div>
    </div>
  );
}

/** A key whose value the API redacted cannot be edited here — echoing the
 *  placeholder back would destroy the real secret (the server rejects it too). */
function isRedacted(value: unknown): boolean {
  try {
    return JSON.stringify(value)?.includes("<redacted>") ?? false;
  } catch {
    return false;
  }
}

/** `origKey` is the key the row was opened with — a renamed row must still be
 *  sent, or its value would be dropped with the unset old key. */
type SettingsDraftRow = {
  key: string;
  origKey: string;
  text: string;
  original: string;
  isNew: boolean;
};

function SettingsBlock({
  source,
  onOpen,
  onToast,
  onChanged,
  onDirty,
}: {
  source: CcSettingsSource;
  onOpen: (p: string) => void;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  const { busy, run } = useConfigAction(onToast, onChanged);
  const [showRaw, setShowRaw] = useState(false);
  const [draft, setDraft] = useState<SettingsDraftRow[] | null>(null);
  const [err, setErr] = useState<string | null>(null);
  // Snapshot taken at Edit: the keys this editor owns and the file's data as it
  // was. Save unsets only keys from THIS snapshot, so a key written meanwhile
  // (the live CLI rewrites settings.json) is never deleted.
  const base = useRef<{ keys: string[]; data: string; draft: string } | null>(null);
  const dirty = draft !== null && JSON.stringify(draft) !== base.current?.draft;
  useReportDirty(`settings:${source.scope}`, dirty, onDirty);

  const data = (source.data as Record<string, unknown> | null | undefined) || {};
  // Redacted keys stay out of the draft and render read-only below the editor;
  // `save` also refuses a new or renamed row that names one, since `set` would
  // replace the real secret (e.g. the whole `env` object) with the typed value.
  const editableKeys = Object.entries(data).filter(([, v]) => !isRedacted(v));
  const redactedKeys = Object.entries(data).filter(([, v]) => isRedacted(v));

  const startEdit = () => {
    setErr(null);
    const next = editableKeys.map(([key, value]) => {
      const text = JSON.stringify(value, null, 2);
      return { key, origKey: key, text, original: text, isNew: false };
    });
    base.current = {
      keys: editableKeys.map(([key]) => key),
      data: JSON.stringify(data),
      draft: JSON.stringify(next),
    };
    setDraft(next);
  };

  const save = async () => {
    if (!draft) return;
    const set: Record<string, unknown> = {};
    const seen = new Set<string>();
    for (const row of draft) {
      const key = row.key.trim();
      if (!key) {
        setErr(t("manage.settingsEmptyKey"));
        return;
      }
      if (seen.has(key)) {
        setErr(t("manage.settingsDupKey", { key }));
        return;
      }
      if (redactedKeys.some(([k]) => k === key)) {
        setErr(t("manage.settingsRedactedKey", { key }));
        return;
      }
      seen.add(key);
      // Only send what actually changed — an untouched key is left alone.
      if (!row.isNew && key === row.origKey && row.text === row.original) continue;
      try {
        set[key] = JSON.parse(row.text);
      } catch {
        setErr(t("manage.settingsBadJson", { key }));
        return;
      }
    }
    const unset = (base.current?.keys ?? []).filter((key) => !seen.has(key));
    if (Object.keys(set).length === 0 && unset.length === 0) {
      setDraft(null);
      return;
    }
    if (
      base.current &&
      JSON.stringify(data) !== base.current.data &&
      !(await confirmDialog({
        title: t("edit.changedOnDiskTitle"),
        message: t("manage.settingsChangedBody"),
        confirmLabel: t("edit.overwrite"),
      }))
    )
      return;
    setErr(null);
    const ok = await run(
      "save",
      () =>
        api.ccConfig.patchSettings({
          scope: source.scope,
          ...(Object.keys(set).length ? { set } : {}),
          ...(unset.length ? { unset } : {}),
        }),
      t("manage.settingsSaved", { file: source.file })
    );
    if (ok) setDraft(null);
  };

  return (
    <div className="rounded-lg border border-border bg-surface-2">
      <div className="border-b border-border px-4 py-2.5 flex items-center gap-2 flex-wrap">
        <ScopeBadge scope={source.scope} />
        <span className="font-mono text-[11px] text-fg-muted truncate flex-1 min-w-0">
          {source.file}
        </span>
        {source.exists ? (
          <>
            <button
              type="button"
              aria-pressed={showRaw}
              onClick={() => setShowRaw((v) => !v)}
              className="text-[11px] font-medium px-2 py-1 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary"
            >
              {showRaw ? t("settings.structured") : t("settings.rawJson")}
            </button>
            <button
              onClick={() => onOpen(source.file)}
              className="text-[11px] font-medium px-2 py-1 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1.5"
            >
              <ExternalLink className="w-3 h-3" />
              {t("common.viewSource")}
            </button>
          </>
        ) : (
          <span className="text-[11px] text-fg-muted">{t("settings.fileMissing")}</span>
        )}
        {draft ? (
          <div className="inline-flex items-center gap-1.5">
            <ActionButton
              icon={X}
              onClick={async () => {
                if (dirty && !(await confirmDiscard())) return;
                setDraft(null);
              }}
              disabled={busy === "save"}
            >
              {t("edit.cancel")}
            </ActionButton>
            <ActionButton icon={Save} onClick={() => void save()} disabled={busy === "save"}>
              {busy === "save" ? t("edit.saving") : t("edit.save")}
            </ActionButton>
          </div>
        ) : (
          <ActionButton icon={Pencil} onClick={startEdit}>
            {t("edit.editButton")}
          </ActionButton>
        )}
      </div>

      {err && (
        <div className="mx-3 mt-3 rounded-lg border border-status-danger/40 bg-status-danger/10 px-3 py-2 text-[11px] text-status-danger flex items-center gap-2">
          <AlertCircle className="w-3.5 h-3.5 flex-shrink-0" />
          <span>{err}</span>
        </div>
      )}

      {draft ? (
        <div className="p-3 space-y-2">
          {draft.map((row, i) => (
            <div key={i} className="rounded-md border border-border bg-surface-1 px-2.5 py-2">
              <div className="flex items-center gap-2">
                <input
                  value={row.key}
                  onChange={(e) =>
                    setDraft((d) =>
                      d ? d.map((r, j) => (j === i ? { ...r, key: e.target.value } : r)) : d
                    )
                  }
                  placeholder={t("manage.settingsKeyPlaceholder")}
                  aria-label={t("manage.settingsKey")}
                  className="h-7 flex-1 min-w-0 bg-surface-2 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                />
                <button
                  type="button"
                  onClick={() => setDraft((d) => (d ? d.filter((_, j) => j !== i) : d))}
                  title={t("manage.settingsRemoveKey")}
                  aria-label={t("manage.settingsRemoveKey")}
                  className="h-7 w-7 flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-status-danger hover:bg-status-danger/10"
                >
                  <Trash2 className="w-3.5 h-3.5" />
                </button>
              </div>
              <textarea
                value={row.text}
                onChange={(e) =>
                  setDraft((d) =>
                    d ? d.map((r, j) => (j === i ? { ...r, text: e.target.value } : r)) : d
                  )
                }
                rows={Math.min(8, row.text.split("\n").length || 1)}
                spellCheck={false}
                aria-label={t("manage.settingsValue")}
                className="mt-1.5 w-full bg-surface-2 border border-border rounded px-2 py-1 text-[11px] font-mono text-fg-secondary focus:outline-none focus:ring-1 focus:ring-accent/40"
              />
            </div>
          ))}
          <button
            type="button"
            onClick={() =>
              setDraft((d) => [
                ...(d ?? []),
                { key: "", origKey: "", text: '""', original: "", isNew: true },
              ])
            }
            className="h-8 w-full text-[11px] font-medium rounded-md border border-dashed border-border bg-surface-2 hover:bg-surface-3 text-fg-secondary inline-flex items-center justify-center gap-1.5"
          >
            <Plus className="w-3 h-3" />
            {t("manage.settingsAddKey")}
          </button>
          <p className="text-[10px] text-fg-muted leading-relaxed">{t("manage.settingsHelp")}</p>
          {redactedKeys.length > 0 && (
            <p className="text-[10px] text-fg-muted leading-relaxed inline-flex items-center gap-1.5">
              <Lock className="w-3 h-3 flex-shrink-0" />
              {t("manage.settingsRedactedKeys", {
                keys: redactedKeys.map(([k]) => k).join(", "),
              })}
            </p>
          )}
        </div>
      ) : (
        source.exists &&
        (showRaw ? (
          <pre className="p-3 text-[11px] font-mono text-fg-secondary overflow-auto max-h-96">
            {JSON.stringify(source.data, null, 2)}
          </pre>
        ) : (
          <SettingsKeyValueList data={source.data as Record<string, unknown> | null | undefined} />
        ))
      )}
    </div>
  );
}

function SettingsKeyValueList({ data }: { data: Record<string, unknown> | null | undefined }) {
  if (!data || typeof data !== "object") {
    return <div className="p-3 text-xs text-fg-muted">-</div>;
  }
  const entries = Object.entries(data);
  if (entries.length === 0) {
    return <div className="p-3 text-xs text-fg-muted">{}</div>;
  }
  return (
    <div className="divide-y divide-border">
      {entries.map(([k, v]) => (
        <div
          key={k}
          className="px-3 py-2 grid grid-cols-1 md:grid-cols-[180px_1fr] gap-1 md:gap-3 items-start"
        >
          <div className="font-mono text-[11px] text-fg-secondary truncate">{k}</div>
          <div className="min-w-0">
            <SettingsValue value={v} />
          </div>
        </div>
      ))}
    </div>
  );
}

function SettingsValue({ value }: { value: unknown }) {
  if (value === null || value === undefined)
    return <span className="text-[11px] text-fg-muted italic">null</span>;
  if (typeof value === "boolean") {
    return (
      <span
        className={`text-[10px] font-mono px-1.5 py-0.5 rounded border ${
          value
            ? "bg-status-success/10 text-status-success border-status-success/30"
            : "bg-surface-4/10 text-fg-secondary border-border-light/30"
        }`}
      >
        {value ? "true" : "false"}
      </span>
    );
  }
  if (typeof value === "number") {
    return <span className="font-mono text-[11px] text-fg-secondary">{value}</span>;
  }
  if (typeof value === "string") {
    return <span className="font-mono text-[11px] text-fg-secondary break-all">{value}</span>;
  }
  if (Array.isArray(value)) {
    if (value.length === 0) return <span className="text-[11px] text-fg-muted">[]</span>;
    return (
      <div className="flex flex-wrap gap-1">
        {value.map((item, i) => (
          <span
            key={i}
            className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border break-all"
          >
            {typeof item === "object" ? JSON.stringify(item) : String(item)}
          </span>
        ))}
      </div>
    );
  }
  // object
  const obj = value as Record<string, unknown>;
  return (
    <div className="space-y-0.5">
      {Object.entries(obj).map(([k, v]) => (
        <div key={k} className="font-mono text-[11px]">
          <span className="text-fg-muted">{k}:</span>{" "}
          <span className="text-fg-secondary break-all">
            {typeof v === "object" ? JSON.stringify(v) : String(v)}
          </span>
        </div>
      ))}
    </div>
  );
}

// ── Memory ────────────────────────────────────────────────────────────

interface MemoryPanelProps {
  items: CcMemoryItem[] | null;
  search: string;
  onOpen: (p: string) => void;
  onEdit: (
    type: CcArtifactType,
    item: { scope: "user" | "project"; name: string; filePath: string }
  ) => void;
  onDelete: (
    type: CcArtifactType,
    scope: "user" | "project",
    name: string | undefined,
    path: string
  ) => void;
  onCreate: (scope: "user" | "project") => void;
  onEditAuto: (item: CcMemoryItem) => void;
  onDeleteAuto: (item: CcMemoryItem) => void;
  onCreateAuto: (project: string) => void;
}

// Strip a leading markdown heading then take a short snippet — used when a
// per-fact memory file has no frontmatter description.
function memoryDescription(m: CcMemoryItem): string {
  return (
    m.frontmatter?.description ||
    m.preview
      .replace(/^#+\s.*\n/, "")
      .trim()
      .slice(0, 200)
  );
}

// Reduce a markdown link target (as written inside MEMORY.md, e.g.
// `./feedback_x.md#section` or `feedback_x.md`) to the bare filename we can
// match against a fact file's `name`. Tolerant of URL-encoding and anchors.
function normalizeMemoryTarget(target: string): string {
  let v = target.trim();
  const hash = v.indexOf("#");
  if (hash >= 0) v = v.slice(0, hash);
  try {
    v = decodeURIComponent(v);
  } catch {
    /* leave as-is when not valid percent-encoding */
  }
  const slash = v.lastIndexOf("/");
  if (slash >= 0) v = v.slice(slash + 1);
  return v.trim();
}

// Render a MEMORY.md preview with its `[label](target.md)` markdown links
// turned into clickable buttons. Everything else is emitted verbatim so the
// surrounding <pre> keeps the original index layout. Clicking a link asks the
// parent to jump to (scroll + highlight) the matching fact file.
function renderMemoryIndex(
  preview: string,
  onJump: (target: string) => void,
  jumpTitle: string
): React.ReactNode {
  const linkRe = /\[([^\]]+)\]\(([^)]+)\)/g;
  const lines = preview.split("\n");
  return lines.map((line, li) => {
    const parts: React.ReactNode[] = [];
    let last = 0;
    let m: RegExpExecArray | null;
    linkRe.lastIndex = 0;
    while ((m = linkRe.exec(line)) !== null) {
      const full = m[0];
      const label = m[1] ?? "";
      const capturedTarget = m[2] ?? "";
      if (m.index > last) parts.push(line.slice(last, m.index));
      parts.push(
        <button
          key={`${li}-${m.index}`}
          type="button"
          onClick={() => onJump(capturedTarget)}
          title={`${jumpTitle}: ${normalizeMemoryTarget(capturedTarget)}`}
          className="text-teal-700 dark:text-teal-300 hover:text-teal-800 dark:hover:text-teal-200 underline decoration-dotted underline-offset-2 hover:decoration-solid focus:outline-none focus:ring-1 focus:ring-teal-400/60 rounded-sm"
        >
          {label}
        </button>
      );
      last = m.index + full.length;
    }
    if (last < line.length) parts.push(line.slice(last));
    return (
      <span key={li}>
        {parts.length ? parts : line}
        {li < lines.length - 1 ? "\n" : null}
      </span>
    );
  });
}

function MemoryPanel({
  items,
  search,
  onOpen,
  onEdit,
  onDelete,
  onCreate,
  onEditAuto,
  onDeleteAuto,
  onCreateAuto,
}: MemoryPanelProps) {
  const { t } = useTranslation("ccConfig");
  const ctx = useContextMenu<CcMemoryItem & { scope: "user" | "project" }>();

  const q = search.trim().toLowerCase();

  const { primary, autoFiltered, groups, missingScopes } = useMemo(() => {
    const list = items ?? [];
    const primaryItems = list.filter(
      (m): m is CcMemoryItem & { scope: "user" | "project" } =>
        m.scope === "user" || m.scope === "project"
    );
    const autoItems = list.filter((m) => m.scope === "auto-memory");

    const matchesAuto = (m: CcMemoryItem) => {
      if (!q) return true;
      const blob = [m.name, m.project, m.frontmatter?.description, m.frontmatter?.name, m.preview]
        .filter(Boolean)
        .join(" ")
        .toLowerCase();
      return blob.includes(q);
    };

    // Search applies to the whole tab — match the CLAUDE.md cards on their
    // scope label, path, and body too so the filter is consistent.
    const primaryFilteredItems = primaryItems.filter((m) => {
      if (!q) return true;
      return [m.scope, m.file, m.preview].join(" ").toLowerCase().includes(q);
    });

    const filtered = autoItems.filter(matchesAuto);

    // Group surviving auto-memory files by their project dir.
    const byProject = new Map<string, CcMemoryItem[]>();
    for (const m of filtered) {
      const key = m.project || "(unknown)";
      if (!byProject.has(key)) byProject.set(key, []);
      byProject.get(key)!.push(m);
    }
    const grouped = [...byProject.entries()].sort((a, b) => a[0].localeCompare(b[0]));

    const present = new Set(primaryItems.map((m) => m.scope));
    const missing = (["user", "project"] as const).filter((s) => !present.has(s));

    return {
      primary: primaryFilteredItems,
      autoFiltered: filtered,
      groups: grouped,
      missingScopes: missing,
    };
  }, [items, q]);

  if (!items) return <SkeletonRows n={2} />;

  const totalAuto = items.filter((m) => m.scope === "auto-memory").length;
  // The "create missing CLAUDE.md" prompts only make sense when not filtering.
  const showMissing = !q;

  return (
    <div className="space-y-3">
      {/* Primary CLAUDE.md memory (user + project) — editable */}
      {ctx.menu && (
        <FileItemMenu
          x={ctx.menu.x}
          y={ctx.menu.y}
          onClose={ctx.close}
          path={ctx.menu.item.file}
          onOpen={() => onOpen(ctx.menu!.item.file)}
          onEdit={() => {
            const m = ctx.menu!.item;
            onEdit("memory", { scope: m.scope, name: "", filePath: m.file });
          }}
          onDelete={() => {
            const m = ctx.menu!.item;
            onDelete("memory", m.scope, undefined, m.file);
          }}
        />
      )}
      {primary.map((m) => (
        <div
          key={m.scope}
          onContextMenu={(e) => ctx.open(e, m)}
          className="rounded-lg border border-border bg-surface-2"
        >
          <div className="border-b border-border px-4 py-2.5 flex items-center gap-2 flex-wrap">
            <ScopeBadge scope={m.scope} />
            <span className="font-mono text-[11px] text-fg-muted truncate flex-1 min-w-0">
              {m.file}
            </span>
            <span className="text-[10px] text-fg-muted">{formatBytes(m.size)}</span>
            <button
              onClick={() => onOpen(m.file)}
              className="text-[11px] font-medium px-2 py-1 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1.5"
            >
              <ExternalLink className="w-3 h-3" />
              {t("common.viewSource")}
            </button>
            <button
              onClick={() => onEdit("memory", { scope: m.scope, name: "", filePath: m.file })}
              className="text-[11px] font-medium px-2 py-1 rounded-md border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1.5"
            >
              <Pencil className="w-3 h-3" />
              {t("edit.editButton")}
            </button>
            <button
              onClick={() => onDelete("memory", m.scope, undefined, m.file)}
              className="text-[11px] font-medium px-2 py-1 rounded-md border border-status-danger/30 bg-status-danger/5 hover:bg-status-danger/15 text-status-danger inline-flex items-center gap-1.5"
            >
              <Trash2 className="w-3 h-3" />
              {t("edit.deleteButton")}
            </button>
          </div>
          <pre className="p-3 text-[11px] font-mono text-fg-secondary whitespace-pre-wrap break-words max-h-72 overflow-auto">
            {m.preview}
            {m.truncated && (
              <span className="text-fg-muted italic">
                {"\n\n"}
                {t("common.truncated")}
              </span>
            )}
          </pre>
        </div>
      ))}

      {showMissing &&
        missingScopes.map((s) => (
          <div
            key={`missing-${s}`}
            className="rounded-lg border border-dashed border-border bg-surface-2 px-4 py-4 flex items-center justify-between gap-3"
          >
            <div className="flex items-center gap-2">
              <ScopeBadge scope={s} />
              <span className="text-xs text-fg-muted">{t("memory.missing")}</span>
            </div>
            <button
              onClick={() => onCreate(s)}
              className="text-[11px] font-medium px-2.5 py-1 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5"
            >
              <Plus className="w-3 h-3" />
              {t("edit.newButton")}
            </button>
          </div>
        ))}

      {/* Per-project file-based memory (~/.claude/projects/<slug>/memory/) */}
      {totalAuto > 0 && (
        <section className="pt-1">
          <div className="flex items-center gap-2 mb-1">
            <BookOpen className="w-3.5 h-3.5 text-teal-700 dark:text-teal-300" />
            <h3 className="text-[11px] font-semibold uppercase tracking-wider text-fg-secondary">
              {t("memory.autoTitle")}
            </h3>
            <span className="text-[10px] px-1.5 py-0.5 rounded-full font-semibold bg-surface-3 text-fg-secondary">
              {q ? `${autoFiltered.length}/${totalAuto}` : totalAuto}
            </span>
          </div>
          <p className="text-[11px] text-fg-muted mb-2.5 leading-relaxed">
            {t("memory.autoSubtitle")}
          </p>

          {groups.length === 0 ? (
            <div className="rounded-lg border border-border bg-surface-2 px-4 py-6 text-center text-sm text-fg-muted">
              {t("memory.noMatches")}
            </div>
          ) : (
            <div className="space-y-2">
              {groups.map(([project, files]) => (
                <MemoryProjectGroup
                  key={project}
                  project={project}
                  files={files}
                  onOpen={onOpen}
                  onEditAuto={onEditAuto}
                  onDeleteAuto={onDeleteAuto}
                  onCreateAuto={onCreateAuto}
                  defaultOpen={!!q || groups.length === 1}
                />
              ))}
            </div>
          )}
        </section>
      )}
    </div>
  );
}

interface MemoryProjectGroupProps {
  project: string;
  files: CcMemoryItem[];
  onOpen: (p: string) => void;
  onEditAuto: (item: CcMemoryItem) => void;
  onDeleteAuto: (item: CcMemoryItem) => void;
  onCreateAuto: (project: string) => void;
  defaultOpen: boolean;
}

function MemoryProjectGroup({
  project,
  files,
  onOpen,
  onEditAuto,
  onDeleteAuto,
  onCreateAuto,
  defaultOpen,
}: MemoryProjectGroupProps) {
  const { t } = useTranslation("ccConfig");
  const [open, setOpen] = useState(defaultOpen);
  // Re-sync when the search-driven default flips (expand on search, collapse
  // when cleared). User toggles within a stable search state are preserved.
  useEffect(() => {
    setOpen(defaultOpen);
  }, [defaultOpen]);

  const indexFiles = files.filter((f) => f.isIndex);
  const factFiles = files.filter((f) => !f.isIndex);
  const ctx = useContextMenu<CcMemoryItem>();

  // Wiring for "click an index entry → jump to its fact file". Fact rows
  // register their DOM node keyed by filename; the index links look them up.
  const rowRefs = useRef<Map<string, HTMLDivElement>>(new Map());
  const [highlighted, setHighlighted] = useState<string | null>(null);
  const highlightTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
  useEffect(
    () => () => {
      if (highlightTimer.current) clearTimeout(highlightTimer.current);
    },
    []
  );

  const rowKey = useCallback((m: CcMemoryItem) => m.name || normalizeMemoryTarget(m.file), []);

  const handleJump = useCallback(
    (target: string) => {
      const name = normalizeMemoryTarget(target);
      const el = rowRefs.current.get(name);
      if (el) {
        el.scrollIntoView({ behavior: "smooth", block: "center" });
        setHighlighted(name);
        if (highlightTimer.current) clearTimeout(highlightTimer.current);
        highlightTimer.current = setTimeout(() => setHighlighted(null), 2200);
        return;
      }
      // Target isn't currently in view (e.g. filtered out by search) — open the
      // underlying file directly if we can resolve it within this project.
      const match = files.find((f) => (f.name || normalizeMemoryTarget(f.file)) === name);
      if (match) onOpen(match.file);
    },
    [files, onOpen]
  );

  return (
    <div className="rounded-lg border border-border bg-surface-2 overflow-hidden">
      {ctx.menu && (
        <FileItemMenu
          x={ctx.menu.x}
          y={ctx.menu.y}
          onClose={ctx.close}
          path={ctx.menu.item.file}
          onOpen={() => onOpen(ctx.menu!.item.file)}
          onEdit={() => onEditAuto(ctx.menu!.item)}
          onDelete={() => onDeleteAuto(ctx.menu!.item)}
        />
      )}
      <div className="flex items-center gap-1 pr-2 hover:bg-surface-3 transition-colors">
        <button
          onClick={() => setOpen((v) => !v)}
          className="flex items-center gap-2 px-3 py-2.5 text-left flex-1 min-w-0"
        >
          <ChevronDown
            className={`w-3.5 h-3.5 text-fg-muted flex-shrink-0 transition-transform ${
              open ? "" : "-rotate-90"
            }`}
          />
          <FolderTree className="w-3.5 h-3.5 text-teal-700 dark:text-teal-300 flex-shrink-0" />
          <span className="font-mono text-xs text-fg-secondary truncate flex-1 min-w-0">
            {project}
          </span>
          <span className="text-[10px] text-fg-muted flex-shrink-0">
            {t("memory.fileCount", { count: files.length })}
          </span>
        </button>
        <button
          onClick={() => onCreateAuto(project)}
          title={t("memory.newFile")}
          className="text-[10px] font-medium px-1.5 py-0.5 rounded border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1 flex-shrink-0"
        >
          <Plus className="w-2.5 h-2.5" />
          {t("memory.newFile")}
        </button>
      </div>

      {open && (
        <div className="border-t border-border p-2.5 space-y-2.5">
          {indexFiles.length > 0 && (
            <div>
              <div className="text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5 px-1">
                {t("memory.indexFiles")}
              </div>
              <div className="space-y-1.5">
                {indexFiles.map((m) => (
                  <MemoryIndexCard
                    key={m.file}
                    item={m}
                    onOpen={onOpen}
                    onEditAuto={onEditAuto}
                    onDeleteAuto={onDeleteAuto}
                    onJump={handleJump}
                    onMenu={ctx.open}
                  />
                ))}
              </div>
            </div>
          )}
          {factFiles.length > 0 && (
            <div>
              <div className="text-[10px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5 px-1">
                {t("memory.factFiles", { count: factFiles.length })}
              </div>
              <div className="space-y-1">
                {factFiles.map((m) => {
                  const key = rowKey(m);
                  return (
                    <MemoryFactRow
                      key={m.file}
                      item={m}
                      onOpen={onOpen}
                      onEditAuto={onEditAuto}
                      onDeleteAuto={onDeleteAuto}
                      onMenu={ctx.open}
                      highlighted={highlighted === key}
                      rowRef={(el) => {
                        if (el) rowRefs.current.set(key, el);
                        else rowRefs.current.delete(key);
                      }}
                    />
                  );
                })}
              </div>
            </div>
          )}
        </div>
      )}
    </div>
  );
}

interface MemoryAutoItemProps {
  item: CcMemoryItem;
  onOpen: (p: string) => void;
  onEditAuto: (item: CcMemoryItem) => void;
  onDeleteAuto: (item: CcMemoryItem) => void;
}

// Compact View / Edit / Delete button cluster shared by index + fact rows.
function MemoryAutoActions({ item, onOpen, onEditAuto, onDeleteAuto }: MemoryAutoItemProps) {
  const { t } = useTranslation("ccConfig");
  return (
    <div className="flex items-center gap-1 flex-shrink-0">
      <button
        onClick={() => onOpen(item.file)}
        title={t("common.viewSource")}
        className="text-[10px] font-medium px-1.5 py-0.5 rounded border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1"
      >
        <ExternalLink className="w-2.5 h-2.5" />
      </button>
      <button
        onClick={() => onEditAuto(item)}
        title={t("edit.editButton")}
        className="text-[10px] font-medium px-1.5 py-0.5 rounded border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1"
      >
        <Pencil className="w-2.5 h-2.5" />
      </button>
      <button
        onClick={() => onDeleteAuto(item)}
        title={t("edit.deleteButton")}
        className="text-[10px] font-medium px-1.5 py-0.5 rounded border border-status-danger/30 bg-status-danger/5 hover:bg-status-danger/15 text-status-danger inline-flex items-center gap-1"
      >
        <Trash2 className="w-2.5 h-2.5" />
      </button>
    </div>
  );
}

function MemoryIndexCard({
  item,
  onOpen,
  onEditAuto,
  onDeleteAuto,
  onJump,
  onMenu,
}: MemoryAutoItemProps & {
  onJump: (target: string) => void;
  onMenu: (e: React.MouseEvent, item: CcMemoryItem) => void;
}) {
  const { t } = useTranslation("ccConfig");
  return (
    <div
      onContextMenu={(e) => onMenu(e, item)}
      className="rounded-md border border-teal-500/20 bg-teal-500/5"
    >
      <div className="flex items-center gap-2 px-3 py-1.5 border-b border-teal-500/15">
        <BookOpen className="w-3 h-3 text-teal-700 dark:text-teal-300 flex-shrink-0" />
        <span className="font-mono text-[11px] text-fg-secondary truncate flex-1 min-w-0">
          {item.name}
        </span>
        <span className="text-[10px] text-fg-muted">{formatBytes(item.size)}</span>
        <MemoryAutoActions
          item={item}
          onOpen={onOpen}
          onEditAuto={onEditAuto}
          onDeleteAuto={onDeleteAuto}
        />
      </div>
      <pre className="px-3 py-2 text-[10.5px] font-mono text-fg-secondary whitespace-pre-wrap break-words max-h-40 overflow-auto">
        {renderMemoryIndex(item.preview, onJump, t("memory.jumpTo"))}
        {item.truncated && <span className="text-fg-muted italic">{"\n…"}</span>}
      </pre>
    </div>
  );
}

function MemoryFactRow({
  item,
  onOpen,
  onEditAuto,
  onDeleteAuto,
  onMenu,
  highlighted,
  rowRef,
}: MemoryAutoItemProps & {
  onMenu: (e: React.MouseEvent, item: CcMemoryItem) => void;
  highlighted?: boolean;
  rowRef?: (el: HTMLDivElement | null) => void;
}) {
  const desc = memoryDescription(item);
  return (
    <div
      ref={rowRef}
      onContextMenu={(e) => onMenu(e, item)}
      className={`flex items-start gap-2.5 rounded-md border px-3 py-2 transition-colors ${
        highlighted
          ? "border-teal-400/70 bg-teal-500/10 ring-1 ring-teal-400/50"
          : "border-border bg-surface-1 hover:border-border/80"
      }`}
    >
      <FileText className="w-3 h-3 text-fg-muted flex-shrink-0 mt-0.5" />
      <div className="min-w-0 flex-1">
        <span className="font-mono text-[11px] text-fg-secondary truncate block">{item.name}</span>
        {desc && (
          <p className="mt-0.5 text-[11px] text-fg-muted leading-snug line-clamp-2">{desc}</p>
        )}
      </div>
      <span className="text-[10px] text-fg-muted flex-shrink-0 mt-0.5">
        {formatBytes(item.size)}
      </span>
      <div className="mt-0.5">
        <MemoryAutoActions
          item={item}
          onOpen={onOpen}
          onEditAuto={onEditAuto}
          onDeleteAuto={onDeleteAuto}
        />
      </div>
    </div>
  );
}

// ── Marketplaces ──────────────────────────────────────────────────────

function MarketplacesPanel({
  data,
  search,
  onToast,
  onChanged,
}: {
  data: CcMarketplacesResponse | null;
  search: string;
  onToast: (t: NonNullable<Toast>) => void;
  onChanged: () => void;
}) {
  const { t } = useTranslation("ccConfig");
  const { busy, run } = useConfigAction(onToast, onChanged);
  const [source, setSource] = useState("");
  const removeArm = useArmed();
  const confirmRemove = removeArm.armed;
  const setConfirmRemove = (name: string | null) =>
    name ? removeArm.arm(name) : removeArm.disarm();
  const ctx = useContextMenu<CcMarketplacesResponse["items"][number]>();
  const update = (name: string) =>
    void run(
      name,
      () => api.ccConfig.marketplaceAction(name, "update"),
      t("manage.marketplaceUpdated", { name })
    );
  const remove = (name: string) => {
    if (confirmRemove !== name) {
      setConfirmRemove(name);
      return;
    }
    setConfirmRemove(null);
    void run(
      name,
      () => api.ccConfig.marketplaceAction(name, "remove"),
      t("manage.marketplaceRemoved", { name })
    );
  };

  const add = useCallback(async () => {
    const value = source.trim();
    if (!value) return;
    const ok = await run(
      "add",
      () => api.ccConfig.addMarketplace(value),
      t("manage.marketplaceAdded", { name: value })
    );
    if (ok) setSource("");
  }, [run, source, t]);

  if (!data) return <SkeletonRows n={3} />;
  const filtered = data.items.filter(
    (m) =>
      !search ||
      m.name.toLowerCase().includes(search.toLowerCase()) ||
      (m.marketplaceName || "").toLowerCase().includes(search.toLowerCase())
  );
  return (
    <div className="space-y-3">
      <ExplainerBanner
        title={t("explain.marketplaces.title")}
        body={t("explain.marketplaces.body")}
        howTo={t("marketplaces.manifest")}
        commands={[{ cmd: t("marketplaces.addCmd"), note: "" }]}
      />
      <div className="rounded-lg border border-accent/25 bg-accent/5 px-3 py-2.5">
        <div className="text-[11px] font-semibold text-fg-secondary mb-1.5">
          {t("manage.addMarketplaceTitle")}
        </div>
        <div className="flex items-center gap-2 flex-wrap">
          <input
            value={source}
            onChange={(e) => setSource(e.target.value)}
            onKeyDown={(e) => {
              if (isSubmitEnter(e)) void add();
            }}
            placeholder={t("manage.addMarketplacePlaceholder")}
            aria-label={t("manage.addMarketplaceTitle")}
            className="h-8 flex-1 min-w-60 bg-surface-1 border border-border rounded px-2 text-[12px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
          />
          <button
            type="button"
            onClick={() => void add()}
            disabled={!source.trim() || busy === "add"}
            className="h-8 text-[11px] font-medium px-3 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <Plus className="w-3 h-3" />
            {busy === "add" ? t("manage.working") : t("manage.addMarketplaceButton")}
          </button>
        </div>
        <p className="mt-1.5 text-[10px] text-fg-muted leading-relaxed">
          {t("manage.addMarketplaceHelp")}
        </p>
      </div>
      <div className="rounded-lg border border-border bg-surface-2 px-3 py-2 flex items-center gap-2 text-[11px] text-fg-muted">
        <FileText className="w-3.5 h-3.5" />
        <span className="font-mono truncate">{data.knownPath}</span>
      </div>
      {filtered.length === 0 ? (
        <div className="rounded-lg border border-border bg-surface-2 px-4 py-6 text-center text-sm text-fg-muted">
          {t("marketplaces.noMarketplaces")}
        </div>
      ) : (
        filtered.map((m) => (
          <div
            key={m.name}
            onContextMenu={(e) => ctx.open(e, m)}
            className="rounded-lg border border-border bg-surface-2 px-4 py-3"
          >
            <div className="flex items-center gap-2 flex-wrap">
              <Store className="w-3.5 h-3.5 text-fg-muted" />
              <span className="font-mono text-sm text-fg-primary">{m.name}</span>
              {m.marketplaceName && m.marketplaceName !== m.name && (
                <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border">
                  {m.marketplaceName}
                </span>
              )}
              {m.pluginCount != null && (
                <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-accent/10 text-accent border border-accent/20">
                  {t("marketplaces.pluginCount")}: {m.pluginCount}
                </span>
              )}
            </div>
            {m.marketplaceDescription && (
              <p className="mt-1.5 text-xs text-fg-secondary leading-relaxed line-clamp-2">
                {m.marketplaceDescription}
              </p>
            )}
            <div className="mt-2 grid grid-cols-1 md:grid-cols-2 gap-x-4 gap-y-1 text-[11px] text-fg-muted">
              {m.source && (
                <div className="col-span-2 truncate">
                  <span className="text-fg-muted">{t("marketplaces.source")}:</span>{" "}
                  <span className="font-mono">
                    {m.source.source === "github" && m.source.repo
                      ? `github.com/${m.source.repo}`
                      : m.source.url || m.source.repo || JSON.stringify(m.source)}
                  </span>
                </div>
              )}
              {m.marketplaceOwner?.name && (
                <div>
                  <span className="text-fg-muted">{t("marketplaces.owner")}:</span>{" "}
                  {m.marketplaceOwner.name}
                </div>
              )}
              {m.lastUpdated && (
                <div>
                  <span className="text-fg-muted">{t("marketplaces.lastUpdated")}:</span>{" "}
                  {new Date(m.lastUpdated).toLocaleString()}
                </div>
              )}
            </div>
            {m.installLocation && (
              <div className="mt-2 flex items-center gap-2">
                <span className="font-mono text-[10px] text-fg-muted truncate flex-1">
                  {m.installLocation}
                </span>
                <CopyButton value={m.installLocation} />
              </div>
            )}
            <div className="mt-3 flex items-center gap-1.5 flex-wrap">
              <ActionButton
                icon={RefreshCw}
                disabled={busy === m.name}
                onClick={() => update(m.name)}
              >
                {t("manage.update")}
              </ActionButton>
              <ActionButton
                icon={Trash2}
                danger
                disabled={busy === m.name}
                onClick={() => remove(m.name)}
              >
                {busy === m.name
                  ? t("manage.working")
                  : confirmRemove === m.name
                    ? t("manage.confirmRemove")
                    : t("manage.remove")}
              </ActionButton>
            </div>
          </div>
        ))
      )}
      {ctx.menu && (
        <ContextMenu x={ctx.menu.x} y={ctx.menu.y} onClose={ctx.close} testId="marketplace-menu">
          <MenuItem
            disabled={busy === ctx.menu.item.name}
            onSelect={() => {
              ctx.close();
              update(ctx.menu!.item.name);
            }}
          >
            {t("manage.update")}
          </MenuItem>
          <MenuItem
            onSelect={() => {
              ctx.close();
              void copyText(ctx.menu!.item.name);
            }}
          >
            {t("common.copyName")}
          </MenuItem>
          {ctx.menu.item.installLocation && (
            <MenuItem
              onSelect={() => {
                ctx.close();
                void copyText(ctx.menu!.item.installLocation!);
              }}
            >
              {t("common.copyPath")}
            </MenuItem>
          )}
          <MenuSeparator />
          <MenuItem
            danger
            disabled={busy === ctx.menu.item.name}
            // Two clicks, like the card's Remove button.
            onSelect={() => {
              if (confirmRemove === ctx.menu!.item.name) ctx.close();
              remove(ctx.menu!.item.name);
            }}
          >
            {confirmRemove === ctx.menu.item.name ? t("manage.confirmRemove") : t("manage.remove")}
          </MenuItem>
        </ContextMenu>
      )}
    </div>
  );
}

// ── Keybindings ───────────────────────────────────────────────────────

function KeybindingsPanel({
  data,
  search,
  onSaved,
  onToast,
  onDirty,
}: {
  data: CcKeybindings | null;
  search: string;
  onSaved: () => void;
  onToast: (toast: NonNullable<Toast>) => void;
  onDirty?: OnDirty;
}) {
  const { t } = useTranslation("ccConfig");
  const [editing, setEditing] = useState(false);
  const [draft, setDraft] = useState<CcKeybindingGroup[]>([]);
  const [saving, setSaving] = useState(false);
  const [err, setErr] = useState<string | null>(null);
  const opened = useRef("");
  useReportDirty("keybindings", editing && JSON.stringify(draft) !== opened.current, onDirty);

  const startEdit = useCallback(() => {
    const groups = data?.groups ?? [];
    // Deep clone so edits never mutate the fetched data.
    const next = groups.map((g) => ({
      context: g.context,
      bindings: g.bindings.map((b) => ({ ...b })),
    }));
    opened.current = JSON.stringify(next);
    setDraft(next);
    setErr(null);
    setEditing(true);
  }, [data]);

  const cancelEdit = useCallback(async () => {
    if (JSON.stringify(draft) !== opened.current && !(await confirmDiscard())) return;
    setEditing(false);
    setDraft([]);
    setErr(null);
  }, [draft]);

  const updateContext = (gi: number, value: string) =>
    setDraft((d) => d.map((g, i) => (i === gi ? { ...g, context: value } : g)));
  const removeContext = (gi: number) => setDraft((d) => d.filter((_, i) => i !== gi));
  const addContext = () =>
    setDraft((d) => [...d, { context: "", bindings: [{ key: "", action: "" }] }]);
  const updateBinding = (gi: number, bi: number, field: "key" | "action", value: string) =>
    setDraft((d) =>
      d.map((g, i) =>
        i === gi
          ? { ...g, bindings: g.bindings.map((b, j) => (j === bi ? { ...b, [field]: value } : b)) }
          : g
      )
    );
  const removeBinding = (gi: number, bi: number) =>
    setDraft((d) =>
      d.map((g, i) => (i === gi ? { ...g, bindings: g.bindings.filter((_, j) => j !== bi) } : g))
    );
  const addBinding = (gi: number) =>
    setDraft((d) =>
      d.map((g, i) => (i === gi ? { ...g, bindings: [...g.bindings, { key: "", action: "" }] } : g))
    );

  const handleSave = useCallback(async () => {
    const groups: CcKeybindingGroup[] = draft.map((g) => ({
      context: g.context.trim(),
      bindings: g.bindings.map((b) => ({ key: b.key.trim(), action: b.action.trim() })),
    }));
    // Mirror the server-side validation so users get instant, local feedback.
    const seen = new Set<string>();
    for (const g of groups) {
      if (!g.context) return setErr(t("keybindings.errContext"));
      if (seen.has(g.context))
        return setErr(t("keybindings.errDupContext", { context: g.context }));
      seen.add(g.context);
      const keys = new Set<string>();
      for (const b of g.bindings) {
        if (!b.key || !b.action) return setErr(t("keybindings.errEmpty", { context: g.context }));
        if (keys.has(b.key))
          return setErr(t("keybindings.errDupKey", { key: b.key, context: g.context }));
        keys.add(b.key);
      }
    }
    setSaving(true);
    setErr(null);
    try {
      const result = await api.ccConfig.writeKeybindings(groups);
      onToast({
        kind: "success",
        message: result.created
          ? t("edit.saveSuccessNew")
          : t("edit.saveSuccess", { path: result.backupPath || "-" }),
      });
      setEditing(false);
      setDraft([]);
      onSaved();
    } catch (e: unknown) {
      const msg = e instanceof Error ? e.message : "unknown error";
      setErr(msg);
      onToast({ kind: "error", message: t("edit.writeError", { message: msg }) });
    } finally {
      setSaving(false);
    }
  }, [draft, onSaved, onToast, t]);

  if (!data) return <SkeletonRows n={3} />;

  const headerBar = (
    <div className="rounded-lg border border-border bg-surface-2 px-3 py-2 flex items-center gap-2 text-[11px] text-fg-muted flex-wrap">
      <FileText className="w-3.5 h-3.5" />
      <span className="font-mono truncate flex-1 min-w-0">{data.file}</span>
      {data.docs && (
        <a
          href={data.docs}
          target="_blank"
          rel="noopener noreferrer"
          className="text-[11px] text-accent hover:underline inline-flex items-center gap-1"
        >
          <ExternalLink className="w-3 h-3" />
          {t("keybindings.docsLink")}
        </a>
      )}
      {editing ? (
        <div className="inline-flex items-center gap-1.5">
          <button
            type="button"
            onClick={cancelEdit}
            disabled={saving}
            className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-border bg-surface-3 hover:bg-surface-1 text-fg-secondary disabled:opacity-50"
          >
            {t("edit.cancel")}
          </button>
          <button
            type="button"
            onClick={handleSave}
            disabled={saving}
            className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5 disabled:opacity-50"
          >
            <Save className="w-3 h-3" />
            {saving ? t("edit.saving") : t("edit.save")}
          </button>
        </div>
      ) : (
        <button
          type="button"
          onClick={startEdit}
          className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-accent/30 bg-accent/10 hover:bg-accent/20 text-accent inline-flex items-center gap-1.5"
        >
          <Pencil className="w-3 h-3" />
          {t("edit.editButton")}
        </button>
      )}
    </div>
  );

  // ── Edit mode ────────────────────────────────────────────────────────
  if (editing) {
    return (
      <div className="space-y-3">
        {headerBar}
        {err && (
          <div className="rounded-lg border border-status-danger/40 bg-status-danger/10 px-3 py-2 text-[11px] text-status-danger flex items-center gap-2">
            <AlertCircle className="w-3.5 h-3.5 flex-shrink-0" />
            <span>{err}</span>
          </div>
        )}
        {draft.map((g, gi) => (
          <div key={gi} className="rounded-lg border border-border bg-surface-2">
            <div className="border-b border-border px-3 py-2 flex items-center gap-2">
              <span className="text-[11px] text-fg-muted flex-shrink-0">
                {t("keybindings.context")}
              </span>
              <input
                value={g.context}
                onChange={(e) => updateContext(gi, e.target.value)}
                placeholder={t("keybindings.contextPlaceholder")}
                className="h-7 flex-1 min-w-0 bg-surface-1 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
              />
              <button
                type="button"
                onClick={() => removeContext(gi)}
                title={t("keybindings.removeContext")}
                aria-label={t("keybindings.removeContext")}
                className="h-7 w-7 flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-status-danger hover:bg-status-danger/10"
              >
                <Trash2 className="w-3.5 h-3.5" />
              </button>
            </div>
            <div className="divide-y divide-border">
              {g.bindings.map((b, bi) => (
                <div key={bi} className="px-3 py-1.5 flex items-center gap-2">
                  <input
                    value={b.key}
                    onChange={(e) => updateBinding(gi, bi, "key", e.target.value)}
                    placeholder={t("keybindings.key")}
                    className="h-7 w-40 flex-shrink-0 bg-surface-1 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                  />
                  <span className="text-fg-muted flex-shrink-0">→</span>
                  <input
                    value={b.action}
                    onChange={(e) => updateBinding(gi, bi, "action", e.target.value)}
                    placeholder={t("keybindings.action")}
                    className="h-7 flex-1 min-w-0 bg-surface-1 border border-border rounded px-2 text-[11px] font-mono text-fg-primary focus:outline-none focus:ring-1 focus:ring-accent/40"
                  />
                  <button
                    type="button"
                    onClick={() => removeBinding(gi, bi)}
                    title={t("keybindings.removeBinding")}
                    aria-label={t("keybindings.removeBinding")}
                    className="h-7 w-7 flex-shrink-0 inline-flex items-center justify-center rounded-md text-fg-muted hover:text-status-danger hover:bg-status-danger/10"
                  >
                    <Trash2 className="w-3.5 h-3.5" />
                  </button>
                </div>
              ))}
              <div className="px-3 py-1.5">
                <button
                  type="button"
                  onClick={() => addBinding(gi)}
                  className="h-7 text-[11px] font-medium px-2.5 rounded-md border border-border bg-surface-3 hover:bg-surface-1 text-fg-secondary inline-flex items-center gap-1.5"
                >
                  <Plus className="w-3 h-3" />
                  {t("keybindings.addBinding")}
                </button>
              </div>
            </div>
          </div>
        ))}
        <button
          type="button"
          onClick={addContext}
          className="h-8 w-full text-[11px] font-medium rounded-md border border-dashed border-border bg-surface-2 hover:bg-surface-3 text-fg-secondary inline-flex items-center justify-center gap-1.5"
        >
          <Plus className="w-3 h-3" />
          {t("keybindings.addContext")}
        </button>
      </div>
    );
  }

  // ── Read-only mode ───────────────────────────────────────────────────
  if (!data.exists) {
    return (
      <div className="space-y-3">
        {headerBar}
        <div className="rounded-lg border border-border bg-surface-2 px-4 py-6 text-center text-sm text-fg-muted">
          {t("keybindings.missing", { path: data.file })}
        </div>
      </div>
    );
  }
  const q = search.toLowerCase();
  return (
    <div className="space-y-3">
      {headerBar}
      {data.groups.map((g) => {
        const filtered = g.bindings.filter(
          (b) =>
            !q ||
            b.key.toLowerCase().includes(q) ||
            b.action.toLowerCase().includes(q) ||
            g.context.toLowerCase().includes(q)
        );
        if (filtered.length === 0) return null;
        return (
          <div key={g.context} className="rounded-lg border border-border bg-surface-2">
            <div className="border-b border-border px-4 py-2 text-xs font-medium text-fg-secondary">
              {t("keybindings.context")}: <span className="text-fg-primary">{g.context}</span>
              <span className="ml-2 text-[10px] text-fg-muted">({filtered.length})</span>
            </div>
            <div className="divide-y divide-border">
              {filtered.map((b) => (
                <div key={b.key} className="px-4 py-1.5 flex items-center gap-3">
                  <kbd className="font-mono text-[11px] px-1.5 py-0.5 rounded bg-surface-3 border border-border text-fg-secondary min-w-20 text-center">
                    {b.key}
                  </kbd>
                  <span className="font-mono text-[11px] text-fg-secondary">{b.action}</span>
                </div>
              ))}
            </div>
          </div>
        );
      })}
    </div>
  );
}

// ── Read-only explainer banner ─────────────────────────────────────────

interface ExplainerBannerProps {
  title: string;
  body: string;
  howTo: string;
  commands: { cmd: string; note: string }[];
}

function ExplainerBanner({ title, body, howTo, commands }: ExplainerBannerProps) {
  return (
    <div className="rounded-lg border border-status-warning/30 bg-status-warning/[0.04] px-4 py-3">
      <div className="flex items-start gap-2">
        <Lock className="w-4 h-4 text-status-warning flex-shrink-0 mt-0.5" />
        <div className="min-w-0 flex-1 space-y-2">
          <div className="text-sm font-medium text-status-warning">{title}</div>
          <p className="text-xs text-fg-secondary leading-relaxed">{body}</p>
          {commands.length > 0 && (
            <div className="pt-1">
              <div className="text-[11px] font-semibold uppercase tracking-wider text-fg-muted mb-1.5">
                {howTo}
              </div>
              <div className="space-y-1.5">
                {commands.map((c, i) => (
                  <CommandSnippet key={i} command={c.cmd} label={c.note} />
                ))}
              </div>
            </div>
          )}
        </div>
      </div>
    </div>
  );
}

// ── Inline copyable command ────────────────────────────────────────────

function CommandSnippet({ command, label }: { command: string; label?: string }) {
  const { t } = useTranslation("ccConfig");
  const [copied, setCopied] = useState(false);
  return (
    <div className="rounded-md border border-border bg-surface-2 px-2.5 py-1.5 flex items-center gap-2">
      <Terminal className="w-3 h-3 text-fg-muted flex-shrink-0" />
      <code className="font-mono text-[11px] text-fg-secondary truncate flex-1">{command}</code>
      {label && (
        <span className="text-[10px] text-fg-muted hidden md:inline truncate">{label}</span>
      )}
      <button
        type="button"
        onClick={async () => {
          if (await copyText(command, true)) {
            setCopied(true);
            setTimeout(() => setCopied(false), 1500);
          }
        }}
        className="text-[10px] font-medium px-1.5 py-1 rounded border border-border bg-surface-1 hover:bg-surface-3 text-fg-secondary hover:text-fg-primary inline-flex items-center gap-1 flex-shrink-0"
        title={t("snippet.copy")}
      >
        {copied ? <Check className="w-3 h-3" /> : <Copy className="w-3 h-3" />}
        <span>{copied ? t("snippet.copied") : t("snippet.copy")}</span>
      </button>
    </div>
  );
}

// ── Backups modal ──────────────────────────────────────────────────────

function BackupsModal({ onClose }: { onClose: () => void }) {
  const { t } = useTranslation("ccConfig");
  const [items, setItems] = useState<CcBackup[] | null>(null);
  const [error, setError] = useState<string | null>(null);

  useEffect(() => {
    api.ccConfig
      .backups()
      .then((r) => setItems(r.items))
      .catch((err: unknown) => setError(err instanceof Error ? err.message : "unknown"));
  }, []);

  const panelRef = useRef<HTMLDivElement>(null);
  useDialog(true, panelRef, onClose);

  return (
    <div
      className="fixed inset-0 bg-surface-0/70 z-50 flex items-center justify-center p-4"
      onClick={onClose}
    >
      <div
        ref={panelRef}
        role="dialog"
        aria-modal="true"
        aria-labelledby="cc-backups-title"
        className="relative w-full max-w-3xl max-h-[85vh] rounded-xl border border-border bg-surface-1 flex flex-col"
        onClick={(e) => e.stopPropagation()}
      >
        <div className="flex items-center gap-2 border-b border-border px-4 py-2.5">
          <History className="w-4 h-4 text-fg-muted" />
          <span id="cc-backups-title" className="text-sm font-medium text-fg-primary flex-1">
            {t("backups.title")}
          </span>
          <button
            type="button"
            onClick={onClose}
            className="text-fg-secondary hover:text-fg-primary p-1 rounded-md hover:bg-surface-3"
            aria-label={t("common.close")}
          >
            <X className="w-4 h-4" />
          </button>
        </div>
        <div className="px-4 py-3 border-b border-border">
          <p className="text-[11px] text-fg-muted leading-relaxed">{t("backups.subtitle")}</p>
        </div>
        <div className="overflow-auto p-4 space-y-2">
          {error && (
            <div className="text-sm text-status-danger inline-flex items-center gap-2">
              <AlertCircle className="w-4 h-4" />
              {error}
            </div>
          )}
          {items === null && !error && <SkeletonRows n={4} />}
          {items !== null && items.length === 0 && (
            <div className="rounded-lg border border-dashed border-border bg-surface-2 px-4 py-8 text-center text-sm text-fg-muted">
              {t("backups.empty")}
            </div>
          )}
          {items?.map((b) => (
            <BackupRow key={b.backupPath} backup={b} />
          ))}
        </div>
      </div>
    </div>
  );
}

function BackupRow({ backup }: { backup: CcBackup }) {
  const { t } = useTranslation("ccConfig");
  // Heuristic restore: copy the backup back over the active path. We don't
  // shell out from the dashboard for this (too risky to silently overwrite
  // a current active version) - show the user a copyable command instead.
  const restoreCmd = restoreCommand(
    backup.backupPath,
    deriveActivePath(backup),
    backup.type === "skills"
  );
  return (
    <div className="rounded-lg border border-border bg-surface-2 px-3 py-2.5">
      <div className="flex items-center gap-2 flex-wrap">
        <ScopeBadge scope={backup.scope} />
        <span className="text-[10px] font-mono px-1.5 py-0.5 rounded bg-surface-3 text-fg-secondary border border-border">
          {backup.type}
        </span>
        <span className="font-mono text-xs text-fg-primary truncate flex-1 min-w-0">
          {backup.name}
        </span>
        <span className="text-[10px] text-fg-muted">{new Date(backup.mtime).toLocaleString()}</span>
        {backup.size != null && (
          <span className="text-[10px] text-fg-muted">{formatBytes(backup.size)}</span>
        )}
      </div>
      <div className="mt-1.5 font-mono text-[10px] text-fg-muted truncate">{backup.backupPath}</div>
      <div className="mt-2">
        <div className="text-[10px] text-fg-muted mb-1">{t("backups.restoreHint")}</div>
        <CommandSnippet command={restoreCmd} />
      </div>
    </div>
  );
}

// Best-effort: derive the active path the backup would restore to. We strip
// the trailing `.<ISO>.bak` segment from the basename and put the result back
// under the right active subdir. If the format doesn't match, fall back to
// "(unknown)" - the user can still copy the backup path itself.
function deriveActivePath(b: CcBackup): string {
  // Strip ".<ISO>.bak" suffix from the basename.
  const m = b.name.match(/^(.+?)\.[^.]+\.bak$/);
  const baseName = m ? m[1] : b.name;
  const backupDir = b.backupPath.replace(/\/[^/]+$/, ""); // dirname
  // Backups live at <root>/cc-config-backups/<type>/<name>.<ts>.bak
  // Active lives at <root>/<type>/<baseName> (or .../skills/<baseName>/SKILL.md handled at use-time)
  const rootMatch = backupDir.match(/^(.*)\/cc-config-backups\/([^/]+)$/);
  if (rootMatch) {
    const root = rootMatch[1];
    const type = rootMatch[2];
    return `${root}/${type}/${baseName}`;
  }
  // memory backups live at <projectRoot>/.cc-config-backups/memory/<name>.<ts>.bak
  const memMatch = backupDir.match(/^(.*)\/\.cc-config-backups\/memory$/);
  if (memMatch) return `${memMatch[1]}/${baseName}`;
  // auto-memory backups live at <memoryDir>/.cc-config-backups/auto-memory/<name>.<ts>.bak
  const autoMatch = backupDir.match(/^(.*)\/\.cc-config-backups\/auto-memory$/);
  if (autoMatch) return `${autoMatch[1]}/${baseName}`;
  return "<active path>";
}

/**
 * The shell command that restores a backup. `cp -a`, never `mv`: the backup
 * survives a wrong restore, and a skill backup is a DIRECTORY — `mv dir active`
 * onto an existing skill dir moves the backup INSIDE it instead of over it, so
 * a directory's CONTENTS are copied into the (re-created) active dir.
 * @param isDir Whether the backup is a directory (a skill).
 */
export function restoreCommand(backupPath: string, activePath: string, isDir: boolean): string {
  const from = shellEscape(backupPath);
  const to = shellEscape(activePath);
  return isDir ? `mkdir -p ${to} && cp -a ${from}/. ${to}/` : `cp -a ${from} ${to}`;
}

// Quote for POSIX shells: wrap in single quotes, escape any embedded single quotes.
export function shellEscape(s: string): string {
  if (/^[A-Za-z0-9_/.@:=+,-]+$/.test(s)) return s;
  return `'${s.replace(/'/g, `'\\''`)}'`;
}