CI Monitor Command

Overview

This public intake copy packages

packages/skills-catalog/skills/(tooling)/nx-ci-monitor

https://github.com/tech-leads-club/agent-skills

Use it when the operator needs the upstream workflow, support files, and repository context to stay intact while the public validator and private enhancer continue their normal downstream flow.

This intake keeps the copied upstream files intact and uses

metadata.json

ORIGIN.md

CI Monitor Command You are the orchestrator for monitoring Nx Cloud CI pipeline executions and handling self-healing fixes. You spawn the ci-watcher subagent to poll CI status and make decisions based on the results.

Imported source sections that did not map cleanly to the public headings are still preserved below or in the support files. Notable imported sections: Context, User Instructions, Configuration Defaults, Nx Cloud Connection Check, Session Context Behavior, Default Behaviors by Status.

When to Use This Skill

Use this section as the trigger filter. It should make the activation boundary explicit before the operator loads files, runs commands, or opens a pull request.

• Use when the request clearly matches the imported source intent: Monitor Nx Cloud CI pipeline status and handle self-healing fixes automatically. Use when user says "watch CI", "monitor pipeline", "check CI status", "fix CI failures", or "self-heal CI". Requires Nx Cloud connection.....
• Use when the operator should preserve upstream workflow detail instead of rewriting the process from scratch.
• Use when provenance needs to stay visible in the answer, PR, or review packet.
• Use when copied upstream references, examples, or scripts materially improve the answer.
• Use when the workflow should remain reviewable in the public intake repo before the private enhancer takes over.

Operating Table

metadata.json

ORIGIN.md

SKILL.md

SKILL.md

## Related Skills

Workflow

This workflow is intentionally editorial and operational at the same time. It keeps the imported source useful to the operator while still satisfying the public intake standards that feed the downstream enhancer flow.

1. Confirm the user goal, the scope of the imported workflow, and whether this skill is still the right router for the task.
2. Read the overview and provenance files before loading any copied upstream support files.
3. Load only the references, examples, prompts, or scripts that materially change the outcome for the current request.
4. Execute the upstream workflow while keeping provenance and source boundaries explicit in the working notes.
5. Validate the result against the upstream expectations and the evidence you can point to in the copied files.
6. Escalate or hand off to a related skill when the work moves out of this imported workflow's center of gravity.
7. Before merge or closure, record what was used, what changed, and what the reviewer still needs to verify.

Imported Workflow Notes

Imported: Context

• Current Branch: !

  git branch --show-current

• Current Commit: !

  git rev-parse --short HEAD

• Remote Status: !

  git status -sb | head -1

Examples

Example 1: Ask for the upstream workflow directly

Use @nx-ci-monitor to handle <task>. Start from the copied upstream workflow, load only the files that change the outcome, and keep provenance visible in the answer.

Explanation: This is the safest starting point when the operator needs the imported workflow, but not the entire repository.

Example 2: Ask for a provenance-grounded review

Review @nx-ci-monitor against metadata.json and ORIGIN.md, then explain which copied upstream files you would load first and why.

Explanation: Use this before review or troubleshooting when you need a precise, auditable explanation of origin and file selection.

Example 3: Narrow the copied support files before execution

Use @nx-ci-monitor for <task>. Load only the copied references, examples, or scripts that change the outcome, and name the files explicitly before proceeding.

Explanation: This keeps the skill aligned with progressive disclosure instead of loading the whole copied package by default.

Example 4: Build a reviewer packet

Review @nx-ci-monitor using the copied upstream files plus provenance, then summarize any gaps before merge.

Explanation: This is useful when the PR is waiting for human review and you want a repeatable audit packet.

Imported Usage Notes

Imported: User Instruction Examples

Users can override default behaviors:

failedTaskIds

Imported: Example Session

Example 1: Normal Flow with Self-Healing (medium verbosity)

[ci-monitor] Starting CI monitor for branch 'feature/add-auth'
[ci-monitor] Config: max-cycles=5, timeout=120m, verbosity=medium

[ci-monitor] Spawning subagent to poll CI status...
[CI Monitor] CI attempt: IN_PROGRESS | Self-Healing: NOT_STARTED | Elapsed: 1m
[CI Monitor] CI attempt: FAILED | Self-Healing: IN_PROGRESS | Elapsed: 3m
[CI Monitor] CI attempt: FAILED | Self-Healing: COMPLETED | Elapsed: 5m

[ci-monitor] Fix available! Verification: COMPLETED
[ci-monitor] Applying fix via MCP...
[ci-monitor] Fix applied in CI. Waiting for new CI attempt...

[ci-monitor] Spawning subagent to poll CI status...
[CI Monitor] New CI attempt detected!
[CI Monitor] CI attempt: SUCCEEDED | Elapsed: 8m

[ci-monitor] CI passed successfully!

[ci-monitor] Summary:
  - Total cycles: 2
  - Total time: 12m 34s
  - Fixes applied: 1
  - Result: SUCCESS

Example 2: Pre-CI Failure (medium verbosity)

[ci-monitor] Starting CI monitor for branch 'feature/add-products'
[ci-monitor] Config: max-cycles=5, timeout=120m, auto-fix-workflow=true

[ci-monitor] Spawning subagent to poll CI status...
[CI Monitor] CI attempt: FAILED | Self-Healing: COMPLETED | Elapsed: 2m

[ci-monitor] Applying fix locally, enhancing, and pushing...
[ci-monitor] Committed: abc1234

[ci-monitor] Spawning subagent to poll CI status...
[CI Monitor] Waiting for new CI attempt... (expected SHA: abc1234)
[CI Monitor] ⚠️  CI attempt timeout (10 min). Returning no_new_cipe.

[ci-monitor] Status: no_new_cipe
[ci-monitor] --auto-fix-workflow enabled. Attempting lockfile update...
[ci-monitor] Lockfile updated. Committed: def5678

[ci-monitor] Spawning subagent to poll CI status...
[CI Monitor] New CI attempt detected!
[CI Monitor] CI attempt: SUCCEEDED | Elapsed: 18m

[ci-monitor] CI passed successfully!

[ci-monitor] Summary:
  - Total cycles: 3
  - Total time: 22m 15s
  - Fixes applied: 1 (self-healing) + 1 (lockfile)
  - Result: SUCCESS

Best Practices

Treat the generated public skill as a reviewable packaging layer around the upstream repository. The goal is to keep provenance explicit and load only the copied source material that materially improves execution.

• Keep the imported skill grounded in the upstream repository; do not invent steps that the source material cannot support.
• Prefer the smallest useful set of support files so the workflow stays auditable and fast to review.
• Keep provenance, source commit, and imported file paths visible in notes and PR descriptions.
• Point directly at the copied upstream files that justify the workflow instead of relying on generic review boilerplate.
• Treat generated examples as scaffolding; adapt them to the concrete task before execution.
• Route to a stronger native skill when architecture, debugging, design, or security concerns become dominant.

Troubleshooting

Problem: The operator skipped the imported context and answered too generically

Symptoms: The result ignores the upstream workflow in

packages/skills-catalog/skills/(tooling)/nx-ci-monitor

metadata.json

ORIGIN.md

Problem: The imported workflow feels incomplete during review

Symptoms: Reviewers can see the generated

SKILL.md

Problem: The task drifted into a different specialization

Symptoms: The imported skill starts in the right place, but the work turns into debugging, architecture, design, security, or release orchestration that a native skill handles better. Solution: Use the related skills section to hand off deliberately. Keep the imported provenance visible so the next skill inherits the right context instead of starting blind.

Related Skills

• @accessibility

  - Use when the work is better handled by that native specialization after this imported skill establishes context.

• @ai-cold-outreach

  - Use when the work is better handled by that native specialization after this imported skill establishes context.

• @ai-pricing

  - Use when the work is better handled by that native specialization after this imported skill establishes context.

• @ai-sdr

  - Use when the work is better handled by that native specialization after this imported skill establishes context.

Additional Resources

Use this support matrix and the linked files below as the operator packet for this imported skill. They should reflect real copied source material, not generic scaffolding.

references

references/n/a

examples

examples/n/a

scripts

scripts/n/a

agents

agents/n/a

assets

assets/n/a

Imported Reference Notes

Imported: User Instructions

$ARGUMENTS

Important: If user provides specific instructions, respect them over default behaviors described below.

Imported: Configuration Defaults

--max-cycles

--timeout

--verbosity

--branch

--subagent-timeout

--fresh

--auto-fix-workflow

--new-cipe-timeout

--local-verify-attempts

Parse any overrides from

$ARGUMENTS

Imported: Nx Cloud Connection Check

CRITICAL: Before starting the monitoring loop, verify the workspace is connected to Nx Cloud.

Step 0: Verify Nx Cloud Connection

1. Check

   nx.json

   at workspace root for

   nxCloudId

   or

   nxCloudAccessToken

2. If

   nx.json

   missing OR neither property exists → exit with:

   [ci-monitor] Nx Cloud not connected. Unlock 70% faster CI and auto-fix broken PRs with https://nx.dev/nx-cloud
   

3. If connected → continue to main loop

Imported: Session Context Behavior

Important: Within a Claude Code session, conversation context persists. If you Ctrl+C to interrupt the monitor and re-run

/ci-monitor

• To continue monitoring: Just re-run

  /ci-monitor

  (context is preserved)
• To start fresh: Use

  /ci-monitor --fresh

  to ignore previous context
• For a completely clean slate: Exit Claude Code and restart

  claude

Imported: Default Behaviors by Status

The subagent returns with one of the following statuses. This table defines the default behavior for each status. User instructions can override any of these.

ci_success

fix_auto_applying

last_cipe_url

fix_available

failedTaskIds

verifiedTaskIds

fix_failed

taskOutputSummary

environment_issue

update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })

no_fix

no_new_cipe

polling_timeout

cipe_canceled

cipe_timed_out

error

no_progress_count

Fix Available Decision Logic

When subagent returns

fix_available

failedTaskIds

verifiedTaskIds

Step 1: Categorize Tasks

1. Verified tasks = tasks in both

   failedTaskIds

   AND

   verifiedTaskIds

2. Unverified tasks = tasks in

   failedTaskIds

   but NOT in

   verifiedTaskIds

3. E2E tasks = unverified tasks where target contains "e2e" (task format:

   <project>:<target>

   or

   <project>:<target>:<config>

   )
4. Verifiable tasks = unverified tasks that are NOT e2e

Step 2: Determine Path

Step 3a: Apply via MCP (fully/e2e-only verified)

• Call

  update_self_healing_fix({ shortLink, action: "APPLY" })

• Record

  last_cipe_url

  , spawn subagent in wait mode

Step 3b: Local Verification Flow

When verifiable (non-e2e) unverified tasks exist:

1. Detect package manager:

   • pnpm-lock.yaml

     exists →

     pnpm nx

   • yarn.lock

     exists →

     yarn nx

   • Otherwise →

     npx nx

2. Run verifiable tasks in parallel:

   • Spawn

     general

     subagents to run each task concurrently
   • Each subagent runs:

     <pm> nx run <taskId>

   • Collect pass/fail results from all subagents

3. Evaluate results:

1. Apply-locally + enhance flow:

   • Run

     nx apply-locally <shortLink>

   • Enhance the code to fix failing tasks
   • Run failing tasks again to verify fix
   • If still failing → increment

     local_verify_count

     , loop back to enhance
   • If passing → commit and push, record

     expected_commit_sha

     , spawn subagent in wait mode

2. Track attempts (wraps step 4):

   • Increment

     local_verify_count

     after each enhance cycle
   • If

     local_verify_count >= local_verify_attempts

     (default: 3):

     • Get code in commit-able state

     • Commit and push with message indicating local verification failed

     • Report to user:

       [ci-monitor] Local verification failed after <N> attempts. Pushed to CI for final validation. Failed: <taskIds>
       

     • Record

       expected_commit_sha

       , spawn subagent in wait mode (let CI be final judge)

Commit Message Format

git commit -m "fix(<projects>): <brief description>

Failed tasks: <taskId1>, <taskId2>
Local verification: passed|enhanced|failed-pushing-to-ci"

Unverified Fix Flow (No Verification Attempted)

When

verificationStatus

FAILED

NOT_EXECUTABLE

couldAutoApplyTasks != true

• Analyze fix content (

  suggestedFix

  ,

  suggestedFixReasoning

  ,

  taskOutputSummary

  )
• If fix looks correct → apply via MCP
• If fix needs enhancement → use Apply Locally + Enhance Flow above
• If fix is wrong → reject via MCP, fix from scratch, commit, push

Auto-Apply Eligibility

The

couldAutoApplyTasks

• true

  : Fix is eligible for auto-apply. Subagent keeps polling while verification is in progress. Returns

  fix_auto_applying

  when verified, or

  fix_available

  if verification fails.

• false

  or

  null

  : Fix requires manual action (apply via MCP, apply locally, or reject)

Key point: When subagent returns

fix_auto_applying

Apply vs Reject vs Apply Locally

• Apply via MCP: Calls

  update_self_healing_fix({ shortLink, action: "APPLY" })

  . Self-healing agent applies the fix in CI and a new CIPE spawns automatically. No local git operations needed.
• Apply Locally: Runs

  nx apply-locally <shortLink>

  . Applies the patch to your local working directory and sets state to

  APPLIED_LOCALLY

  . Use this when you want to enhance the fix before pushing.
• Reject via MCP: Calls

  update_self_healing_fix({ shortLink, action: "REJECT" })

  . Marks fix as rejected. Use only when the fix is completely wrong and you'll fix from scratch.

Apply Locally + Enhance Flow

When the fix needs enhancement (use

nx apply-locally

1. Apply the patch locally:

   nx apply-locally <shortLink>

   (this also updates state to

   APPLIED_LOCALLY

   )

2. Make additional changes as needed

3. Commit and push:

   git add -A
   git commit -m "fix: resolve <failedTaskIds>"
   git push origin $(git branch --show-current)
   

4. Loop to poll for new CIPE

Reject + Fix From Scratch Flow

When the fix is completely wrong:

1. Call MCP to reject:

   update_self_healing_fix({ shortLink, action: "REJECT" })

2. Fix the issue from scratch locally

3. Commit and push:

   git add -A
   git commit -m "fix: resolve <failedTaskIds>"
   git push origin $(git branch --show-current)
   

4. Loop to poll for new CIPE

Environment Issue Handling

When

failureClassification == 'ENVIRONMENT_STATE'

1. Call MCP to request rerun:

   update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })

2. New CIPE spawns automatically (no local git operations needed)
3. Loop to poll for new CIPE with

   previousCipeUrl

   set

No-New-CIPE Handling

When

status == 'no_new_cipe'

This means the expected CIPE was never created - CI likely failed before Nx tasks could run.

1. Report to user:

   [ci-monitor] No CI attempt for <sha> after 10 min. Check CI provider for pre-Nx failures (install, checkout, auth). Last CI attempt: <previousCipeUrl>
   

2. If user configured auto-fix attempts (e.g.,

   --auto-fix-workflow

   ):

   • Detect package manager: check for

     pnpm-lock.yaml

     ,

     yarn.lock

     ,

     package-lock.json

   • Run install to update lockfile:

     pnpm install   # or npm install / yarn install
     

   • If lockfile changed:

     git add pnpm-lock.yaml  # or appropriate lockfile
     git commit -m "chore: update lockfile"
     git push origin $(git branch --show-current)
     

   • Record new commit SHA, loop to poll with

     expectedCommitSha

3. Otherwise: Exit with

   no_new_cipe

   status, providing guidance for user to investigate

Imported: Exit Conditions

Exit the monitoring loop when ANY of these conditions are met:

cipeStatus == 'SUCCEEDED'

Imported: Main Loop

Step 1: Initialize Tracking

cycle_count = 0
start_time = now()
no_progress_count = 0
local_verify_count = 0
last_state = null
last_cipe_url = null
expected_commit_sha = null

Step 2: Spawn Subagent

Spawn the

ci-watcher

Fresh start (first spawn, no expected CIPE):

Task(
  agent: "ci-watcher",
  prompt: "Monitor CI for branch '<branch>'.
           Subagent timeout: <subagent-timeout> minutes.
           New-CIPE timeout: <new-cipe-timeout> minutes.
           Verbosity: <verbosity>."
)

After action that triggers new CIPE (wait mode):

Task(
  agent: "ci-watcher",
  prompt: "Monitor CI for branch '<branch>'.
           Subagent timeout: <subagent-timeout> minutes.
           New-CIPE timeout: <new-cipe-timeout> minutes.
           Verbosity: <verbosity>.

           WAIT MODE: A new CIPE should spawn. Ignore old CIPE until new one appears.
           Expected commit SHA: <expected_commit_sha>
           Previous CIPE URL: <last_cipe_url>"
)

Step 3: Handle Subagent Response

When subagent returns:

1. Check the returned status
2. Look up default behavior in the table above
3. Check if user instructions override the default
4. Execute the appropriate action
5. If action expects new CIPE, update tracking (see Step 3a)
6. If action results in looping, go to Step 2

Step 3a: Track State for New-CIPE Detection

After actions that should trigger a new CIPE, record state before looping:

last_cipe_url = current cipeUrl

last_cipe_url = current cipeUrl

expected_commit_sha = $(git rev-parse HEAD)

expected_commit_sha = $(git rev-parse HEAD)

expected_commit_sha = $(git rev-parse HEAD)

expected_commit_sha = $(git rev-parse HEAD)

last_cipe_url = current cipeUrl

expected_commit_sha = $(git rev-parse HEAD)

CRITICAL: When passing

expectedCommitSha

last_cipe_url

• Subagent will completely ignore the old/stale CIPE
• Subagent will only wait for new CIPE to appear
• Subagent will NOT return to main agent with stale CIPE data
• Once new CIPE detected, subagent switches to normal polling

Why wait mode matters for context preservation: Stale CIPE data can be very large (task output summaries, suggested fix patches, reasoning). If subagent returns this to main agent, it pollutes main agent's context with useless data since we already processed that CIPE. Wait mode keeps stale data in the subagent, never sending it to main agent.

Step 4: Progress Tracking

After each action:

• If state changed significantly → reset

  no_progress_count = 0

• If state unchanged →

  no_progress_count++

• On new CI attempt detected → reset

  local_verify_count = 0

Imported: Status Reporting

Based on verbosity level:

minimal

medium

verbose

Imported: Error Handling

nx apply-locally

--auto-fix-workflow