PluginBench
Skill
Review
Audit score 70

cx-cases

coralogix/cx-cli

Triage and manage Coralogix Cases—acknowledge, assign, resolve, and track investigation timelines.

What is cx-cases?

This skill provides CLI commands to inspect and drive Coralogix Cases through their lifecycle (active → acknowledged → resolved → closed). Use it to assign cases to team members, record investigation findings, set priorities, and manage case status during incident response.

  • Inspect case details including groupings, labels, impacted entities, KPI breaches, and AI summaries
  • Assign cases to team members by email and acknowledge to signal active investigation
  • Add comments and investigation notes to the case timeline for team visibility
  • Transition cases through lifecycle states: active, acknowledged, resolved, and closed
  • Override computed priority (P1–P5) based on actual impact
  • View event timelines showing status changes, assignments, and comments

How to install cx-cases

npx skills add https://github.com/coralogix/cx-cli --skill cx-cases
Prerequisites
  • Coralogix account with Cases feature enabled
  • cx CLI installed and authenticated with valid credentials
  • User email address for case assignment operations
Claude Code
Cursor
Windsurf
Cline

How to use cx-cases

  1. 1.Run `cx cases get <id>` to fetch and inspect a case's details, groupings, and priority
  2. 2.Assign the case to yourself or a teammate: `cx cases assign <id> --user you@example.com`
  3. 3.Acknowledge the case to signal active investigation: `cx cases acknowledge <id>`
  4. 4.Add investigation notes as you work: `cx cases comment <id> --text "<finding>"`
  5. 5.Optionally adjust priority if impact differs: `cx cases set-priority <id> --priority P1`
  6. 6.Once root cause is confirmed, resolve with a reason: `cx cases resolve <id> --reason "<postmortem>" --yes`
  7. 7.Close the case: `cx cases close <id>`
  8. 8.View the full timeline: `cx cases events list <case-id>`

Use cases

Good for
  • Triage an alert by fetching case details, then assigning it to the on-call engineer and acknowledging
  • Document root-cause findings and remediation steps as comments during investigation
  • Resolve a confirmed incident with a postmortem reason, then close the case
  • Re-prioritize a case from P3 to P1 when impact assessment reveals higher severity
  • Review the full event timeline and notification history for a case to audit incident response
Who it's for
  • On-call engineers and incident responders managing active cases
  • SRE and DevOps teams triaging reliability and availability incidents
  • Platform teams investigating security or availability cases
  • Engineering managers reviewing case resolution and team assignments

cx-cases FAQ

Can I reopen a resolved case?

No. Resolution is irreversible—a resolved case can only move to closed. If uncertain, stay in acknowledged (reversible via unacknowledge) until confident.

What's the difference between resolve and close?

Resolve marks a case as investigated with a postmortem reason; close is the terminal state. For false alarms, close directly from active to skip resolve.

Can I bulk-update multiple cases?

There are no bulk endpoints. Pipe case IDs through a loop, e.g., `... | jq -r '.[].id' | xargs -I {} cx cases acknowledge {}`.

What should I use for the assign --user parameter?

Always use the team member's email address, never a user ID. The email is visible in all output and is the canonical identifier.

Can I change priority after resolving a case?

No. Priority overrides are only possible while a case is still open (active or acknowledged). Once resolved or closed, priority cannot be changed.

Full instructions (SKILL.md)

Source of truth, from coralogix/cx-cli.


name: cx-cases description: > Triage and manage Coralogix Cases with the cx cases CLI — e.g. acknowledge, assign, resolve, or re-prioritize a case, or inspect its event timeline or notification deliveries. metadata: version: "0.1.0"

Cases Management Skill

A Case groups related alert events into one investigation unit with a status, priority, category, and assignee. Use this skill to inspect cases and drive them through their lifecycle (active → acknowledged → resolved → closed).

CLI Commands

CommandPurpose
cx cases get <id>Get a single case by ID
cx cases update <id> [--title] [--resolution-reason]Update mutable fields
cx cases comment <id> --text <text>Add a comment to the case timeline
cx cases assign <id> --user <email>Assign a case (email, or raw user ID)
cx cases unassign <id>Remove the assignee
cx cases acknowledge <id>Acknowledge (signals you're working it; stops re-notification)
cx cases unacknowledge <id>Remove the acknowledgment
cx cases resolve <id> --reason <text>Resolve a case (irreversible — see below)
cx cases close <id>Close a case (terminal)
cx cases set-priority <id> --priority <P1..P5>Override the computed priority
cx cases clear-priority <id>Remove a priority override
cx cases events list <case-id>Event timeline (status changes, comments, assignments)
cx cases events get <event-id>A single event — drill in, e.g. to expand a comment thread
cx cases notifications <case-id> [<case-id> ...]Notification deliveries (connector, status, time)

Case Lifecycle

PENDING_ACTIVATION ──► ACTIVE ◄────────► ACKNOWLEDGED
                         │ ╲                │ ╲
                         │  ╲               │  ╲
                         ▼   ╲              ▼   ╲
                      CLOSED  ╲──► RESOLVED ◄─── (from ACK)
                                       │
                                       ▼
                                    CLOSED  (terminal)
From stateAllowed transitionsNotes
PENDING_ACTIVATION→ ACTIVESystem-driven activation; not user-controllable
ACTIVE→ ACKNOWLEDGED, RESOLVED, CLOSEDAck is optional; for a false alarm, close directly (skip resolve)
ACKNOWLEDGED→ ACTIVE, RESOLVED, CLOSEDThe only "back" transition: unacknowledge returns it to ACTIVE
RESOLVED→ CLOSED onlyIrreversible — cannot reopen to ACTIVE/ACKNOWLEDGED
CLOSED(none)Terminal

Categories: AVAILABILITY or SECURITY. Priorities: P1 (highest) → P5.

Triage Workflow

  1. Inspect — cx cases get <id>. The payload includes groupings, labels, impactedEntities, kpiBreaches, aiSummary, and both priorityDetails.system (computed) and priorityDetails.override (user-set).
  2. Investigate — Pull the underlying telemetry by querying the alert's DataPrime / PromQL to find root cause before acting. Optionally export the investigation via cx olly or pull the case's impactedEntities / groupings to confirm the impact. See the cx-telemetry-querying skill.
  3. Claim — cx cases assign <id> --user you@example.com then cx cases acknowledge <id>.
  4. Record findings — cx cases comment <id> --text "<note>" to leave investigation notes on the timeline (root cause, links, next steps) as you go. Comments appear as comment events in cx cases events list.
  5. Resolve or close — see below.
  6. Re-prioritize if impact differs from the computed value — cx cases set-priority <id> --priority P1 / clear-priority. Only possible while the case is still open; priority cannot be overridden once a case is RESOLVED or CLOSED.

Resolving

Resolution is irreversible (a RESOLVED case can only move to CLOSED), so the CLI requires both a reason and a confirmation:

  • Pass --reason "<text>" — a one-line postmortem (root cause, what fixed it, follow-up) visible to teammates in the timeline. Use --no-reason only when a reason genuinely doesn't apply.
  • In agent / non-interactive mode, also pass --yes; without it the command refuses and must be handed to the user to run interactively.

If uncertain, stay in ACKNOWLEDGED (reversible via unacknowledge) until confident. For non-resolution edits (title, post-hoc postmortem link), use cx cases update.

Bulk Operations

There are no bulk endpoints. To act on many cases, pipe IDs through a loop, e.g. ... | jq -r '.[].id' | xargs -I {} cx cases acknowledge {}.

Key Principles

  • Use emails, never user IDs — for assign --user and in all output.
  • resolve is irreversible and close is terminal — confirm before resolving; for false alarms close from ACTIVE directly.
  • Always supply a resolution reason unless --no-reason truly applies.
  • P1-style shorthand is accepted anywhere a priority/status/category is expected.
  • Multi-profile fan-out with -p <profile> (repeatable) for cross-environment triage.
  • Link to a specific case — build <base>/cases?id=<case_id>, where <base> is the console URL already seen in a `View in Coralogix: <base>/...` line printed by any `cx cases` command this session — never fabricate `<base>` yourself.

References

Related Skills

  • cx-alerts — the alert definitions behind the events grouped into a case.
  • cx-slos — the SLO definitions whose breaches drive reliability cases.
  • cx-telemetry-querying — pivot from a case's impacted entities into logs/spans/metrics.