`<Card hover>` unconditionally added `cursor-pointer` on top of the
visual hover effects (border tint + shadow lift). That made stat
cards, FangHub skill cards in browse view, and any other purely
informational cards display a pointer cursor — users naturally click
them and get nothing back.

Reported as "drawer doesn't open" on /dashboard/skills (default
source is `fanghub`, where SkillCard is rendered without
`onViewDetail` by design — those cards aren't meant to drill in,
but they still looked clickable). Same UX trap on /dashboard/plugins
and /dashboard/mcp where the cards have no detail drawer at all,
and on Hands' running-now chips.

Fix: gate `cursor-pointer` on the presence of an `onClick` handler.
The `hover` prop now only controls the visual hover tint/lift it
was always meant to control, and clickability is signalled by what
actually exists on the element.

Verified: pnpm typecheck.

Followup on the cursor-pointer fix in this PR. Those pages didn't
have a detail drawer at all, so even with the cursor honest, users
can't drill into a plugin/server/FangHub-skill they're curious about.
Add inline DrawerPanel-based detail surfaces, matching the patterns
already used by HandsPage / ChannelsPage / ClawHub skill cards.

PluginsPage:
  - Plugin list rows now clickable (role=button), opens a drawer
    showing name + version + author + full description + hooks +
    metadata (size, install path), with Install-deps and Uninstall
    actions inside the drawer. Existing inline action buttons keep
    working (already stop propagation).

McpServersPage:
  - ServerCard's body region (header + stats + transport summary)
    is now clickable to open a drawer showing transport details
    (command + args, or url), env vars, headers, OAuth state when
    pending, and the full tools list. Edit / Taint / Delete actions
    are mirrored inside the drawer for one-click reach. Bottom
    Edit/Taint/Delete buttons and the Tools expand-toggle keep
    working as before (they're outside the clickable region).

SkillsPage:
  - FangHub SkillCard, previously a dead card with no detail surface,
    now passes onViewDetail to a new inline DrawerPanel showing
    name + version + author + full description + tags, with the
    same Install button as the marketplace card. ClawHub / SkillHub
    detail flows are unchanged.

Verified:
  - pnpm typecheck, pnpm build pass
  - Playwright: clicking a FangHub skill card opens the drawer with
    the right content. Plugin/MCP equivalents follow the same
    pattern (couldn't reproduce live without seed data, but the
    code paths are isomorphic to the verified SkillsPage one).

#3418)

* feat(kernel/workflow): pause/resume foundation for resumable workflows

Closes part of #3335. ApprovalManager integration, REST/CLI surface,
and DAG-path support are explicit follow-ups (see PR description).

Adds the state machine + persistence primitives that make
"pause-mid-pipeline, resume-from-the-same-step" possible. Today the
workflow engine runs to completion or fails; with this PR a caller can
lodge a pause request, the sequential executor honors it at the next
step boundary, and a later `resume_run` call replays from the saved
snapshot.

What lands:

- `WorkflowRunState::Paused { resume_token, reason, paused_at }` —
  carries the token a caller must present to `resume_run`. Existing
  `is_paused()` helper for ergonomic matches.
- `WorkflowRun` gains four fields, all `#[serde(default)]` /
  `skip_serializing_if` for backward compat with persisted JSON:
    - `pause_request: Option<PauseRequest>` (set by `pause_run`,
      consumed at the next step boundary)
    - `paused_step_index: Option<usize>` (where to resume)
    - `paused_variables: HashMap<String, String>` (`{{var}}` bindings)
    - `paused_current_input: Option<String>` (input that would have
      fed the paused step, restored on resume)
- New `PauseRequest { reason, resume_token }`. Token is generated when
  `pause_run` is called so callers can begin waiting on the
  corresponding approval / input artifact before the executor has
  honored the request — the executor reuses the same token at the
  transition.
- `WorkflowEngine::pause_run(run_id, reason) -> Uuid`
    - Idempotent: paused-already returns the existing token.
    - Errors on Completed / Failed.
- `WorkflowEngine::resume_run(run_id, token, resolver, sender) -> Result<String>`
    - Verifies state is `Paused` and token matches.
    - Restores snapshot, flips state to `Running`, re-enters
      `execute_run_sequential`. Snapshot fields are cleared on
      successful resume; a wrong-token attempt leaves state untouched.
- `execute_run_sequential` reads `pause_request` at the top of every
  step iteration. On honoring, snapshots `(step_index, variables,
  current_input)` into the run, transitions to `Paused`, returns the
  intermediate output without erroring. In-flight steps are allowed
  to finish — partial-step rollback would be a much bigger feature.
- `execute_run_dag` refuses cleanly if a pause request was lodged,
  rather than silently dropping it. Pause/resume on DAG runs is the
  follow-up.
- `persist_runs` filter extended to include `Paused`. Paused runs
  round-trip through daemon restart with their token + snapshot
  intact; a fresh `load_runs` call restores them and a subsequent
  `resume_run` works as if no restart had happened.

Tests (5 new in `workflow::tests`):

- `pause_after_first_step_then_resume_finishes_workflow` — sender
  triggers pause from inside step 1; loop honors at the boundary
  before step 2; resume completes the run with both
  `step_results.len() == 2` and snapshot fields cleared.
- `resume_run_with_wrong_token_is_rejected` — resume with a fresh
  random token errors and leaves state Paused.
- `resume_run_on_non_paused_run_is_rejected` — resume on a run still
  in Pending errors with "expected Paused".
- `paused_run_round_trips_through_persist_and_load` (multi-thread
  flavor) — Phase 1 builds a paused run on engine #1 and lets
  `execute_run`'s built-in `persist_runs_async` flush; Phase 2 loads
  into engine #2 via `block_in_place(load_runs)` and asserts the
  resume_token + snapshot survive.
- `pause_request_on_dag_workflow_returns_explicit_error` — a paused
  request on a DAG workflow returns the explicit "follow-up needed"
  error rather than silently completing.

Pre-flight: `cargo clippy --workspace --all-targets -- -D warnings`
clean, `cargo test -p librefang-kernel --lib --no-fail-fast` 637
passed (5 new, no regressions).

Out of scope (tracked as follow-ups against the same #3335):

- ApprovalManager wiring — a step returning "needs approval" should
  trigger pause + register with the existing TOTP/escalation flow.
  This PR's primitive is the substrate that integration uses.
- API endpoints `POST /api/workflows/runs/{id}/resume` and
  `GET /api/workflows/runs/paused` for dashboard / external callers.
- CLI `librefang workflow run paused list / resume <id>`.
- DAG executor pause/resume support (per-layer checkpoints).
- GC for paused workflows older than a configurable TTL.
- Capability check that the approver matches the original requester.

* fix(kernel/workflow): preserve resume snapshot on failure + tighten pause hygiene

Address review feedback on #3418:

1. Resume snapshot preserved across failure. `execute_run_sequential`
   used to `take()` the snapshot on entry, so any step error after
   restoration left the run as Failed with no recovery data — a future
   retry-from-failure path was structurally impossible. Switched to
   clone-on-read; the snapshot is now authoritatively cleared only
   when the run reaches Completed. Failed runs carry their snapshot
   forward (forward-compat for retry semantics). The pause-mid-loop
   branch already overwrites the snapshot with fresh values when
   transitioning back to Paused, so no stale data leaks.

2. Orphan `pause_request` cleanup. If a pause request was lodged
   between the loop's final step-boundary check and the run's
   completion, `pause_request` survived as dead data on Completed
   runs. The Completed transition now clears `pause_request`,
   `paused_step_index`, `paused_variables`, and
   `paused_current_input` together, keeping the invariant 'snapshot
   fields valid only on Paused (or Failed retry-candidates)'.

3. `paused_variables: HashMap → BTreeMap`. The persisted JSON now
   has stable key order — re-serializing a Paused run twice produces
   byte-identical output, which keeps audit logs and external
   snapshots clean. Mirrors the project's existing
   deterministic-ordering convention for LLM-bound prompt data
   (#3298) even though pause snapshots don't directly enter prompts.

4. `paused_at` doc comment: pointed at the future TTL-based GC
   sweep that will consume it (#3335 GC follow-up), so future
   readers know the field has a downstream consumer.

`cargo test -p librefang-kernel --lib workflow` passes (65 tests,
including `paused_run_round_trips_through_persist_and_load`).
`cargo test -p librefang-api --test config_schema_golden` clean
(no fixture drift).

* fix(kernel/workflow): pause/resume foundation review fixups

Address review feedback on PR #3418 (open). Picks up the
already-uncommitted improvements (BTreeMap-backed paused_variables for
deterministic JSON, clone-not-take in resume snapshot read,
Completed-path snapshot clear on the sequential happy path) and adds
the items the multi-angle review flagged:

1. **DAG ghost-state cleanup (quality BUG, security FIX-doc).** The
   DAG entry guard previously returned `Err(...)` and left
   `pause_request: Some(_)` on a run still in `Running`, so an
   unrunnable workflow looked alive forever. The guard now flips the
   run to `Failed` with a descriptive `error` field before returning,
   and a new `cleanup_terminal_pause_state` post-pass at the bottom
   of `execute_run` / `resume_run` clears every pause field on any
   terminal transition (Completed or Failed) — so the same five
   `clear_pause_state` lines aren't sprinkled across the ~10 mid-step
   `Failed` sites in the existing executors.

2. **Rollback safety on `load_runs` (quality OK-with-caveat).**
   Previously a single bad row in `workflow_runs.json` killed the
   whole `Vec<WorkflowRun>` deserialization, so an old daemon reading
   a file written by a newer one (e.g. one with the new tagged
   `Paused { ... }` variant) would lose all run history. Now parses
   per-row via `Vec<serde_json::Value>` first, attempts each
   `from_value::<WorkflowRun>` independently, and skips unrecognized
   rows with a WARN. Newer daemons reading older files still parse
   cleanly because every post-foundation field is `#[serde(default)]`.

3. **Security doc-comments (security FIX-doc).** Added explicit
   warnings on `PauseRequest.reason` /
   `WorkflowRunState::Paused { reason }`: persisted plaintext to
   `workflow_runs.json`, surfaced to operators — not a secret store.
   Same `# SECURITY:` block on `PauseRequest.resume_token`: tokens are
   plaintext at rest in the foundation; the future REST handler must
   hash-at-rest before that surface ships. Added a "DAG workflows
   fail-closed on pause" warning to `pause_run`'s docs so a
   confused caller does not silently brick a DAG run.

4. **Three new tests (quality MISS).**
   - `pause_run_is_idempotent_returns_same_token`: triple-call returns
     the same Uuid; the *first* reason wins (later calls don't
     overwrite the message in logs / UI).
   - `resume_run_after_completion_is_rejected`: pause → execute →
     resume to completion → second resume with the same token errors
     with "expected Paused".
   - `pause_then_execute_on_pending_pauses_at_step_zero`: lock down
     the pause-before-any-step path explicitly (was previously only
     exercised as a side-effect of `resume_run_with_wrong_token`).
   - Existing DAG-pause test extended to assert the new
     `state == Failed` + `pause_request is None` shape.

Pre-flight: `cargo clippy --workspace --all-targets -- -D warnings`
clean, `cargo test -p librefang-kernel --lib --no-fail-fast` 642
passed (8 pause/resume tests, 0 regressions).

Out of scope, still tracked against #3335:
- ApprovalManager wiring + capability check (approver matches the
  original requester).
- REST `POST /api/workflows/runs/{id}/resume` and `GET /api/workflows/runs/paused`.
- CLI `librefang workflow run paused list / resume <id>`.
- Per-layer DAG pause/resume (today: fail-closed).
- GC for paused workflows older than a configurable TTL.
- Hash-at-rest for `resume_token` in `workflow_runs.json`.
- WorkflowPaused / WorkflowResumed hook events for external observers.