docs(nx-plugin): add guide on writing performant createNodes v2 plugins

Document practical patterns and caveats for keeping createNodesV2 plugins
fast: prefer the batched v2 API, cache results to disk with a content hash,
hoist shared work out of the per-file loop, load configs in parallel, keep
globs narrow and output deterministic, and avoid per-file process spawning.
Also covers daemon/cache dev overrides and diagnosing slow graph creation
with NX_PERF_LOGGING and nx report.

Generated with [Linear](https://linear.app/nxdev/issue/DOC-516/document-performant-createnodes-v2-plugin-patterns#agent-session-07d2f00a)

Co-authored-by: linear-code[bot] <222613912+linear-code[bot]@users.noreply.github.com>

.cargo/config.toml

@@ -1,3 +1,6 @@
+[env]
+JEMALLOC_SYS_WITH_MALLOC_CONF = "dirty_decay_ms:1000,muzzy_decay_ms:0"
+
 [build]
 target-dir = 'dist/target'
 

.circleci/config.yml

@@ -1,37 +0,0 @@
-version: 2.1
-
-# -------------------------
-#        EXECUTORS
-# -------------------------
-
-defaults: &defaults
-  working_directory: ~/repo
-
-executors:
-  linux:
-    <<: *defaults
-    docker:
-      - image: cimg/rust:1.84.0-browsers
-    resource_class: small
-
-# -------------------------
-#          JOBS
-# -------------------------
-jobs:
-  # -------------------------
-  #     JOBS: Main Linux
-  # -------------------------
-  main-linux:
-    executor: linux
-    steps:
-      - run: echo "We are in the process of transitioning from Circle CI to GitHub Actions. For details about your build results, consult github actions build logs."
-
-# -------------------------
-#        WORKFLOWS(JOBS)
-# -------------------------
-workflows:
-  version: 2
-
-  build:
-    jobs:
-      - main-linux

.claude/disabled-skills/diagnose-sandbox-report/DISABLED.md

@@ -0,0 +1,3 @@
+This skill is disabled to encourage use of the AI prompt from the nx cloud sandboxing dashboard.
+
+If you still need the original skill, you can reference it with @./claude/disabled-skills/diagnose-sandbox-report/SKILL.md directly.

.claude/disabled-skills/diagnose-sandbox-report/SKILL.md

@@ -0,0 +1,301 @@
+---
+name: diagnose-sandbox-report
+description: >
+  Diagnose Nx sandbox violations from a sandbox report. Use when asked to
+  "diagnose sandbox", "analyze sandbox report", "investigate sandbox violations",
+  "check violations", when given a sandbox report JSON file or URL to investigate,
+  or when the user pastes a staging.nx.app sandbox-report URL. Also trigger when
+  discussing unexpected reads/writes in Nx task execution. Guides structured
+  investigation of why tasks read/write undeclared files, determines root causes,
+  and recommends fixes.
+argument-hint: '<sandbox-report.json or URL> [--filter <file|pattern|list>]'
+allowed-tools: Bash, Read, Grep, Glob
+---
+
+# Diagnose Sandbox Report
+
+## Overview
+
+Sandbox violations occur when an Nx task reads files not declared as inputs or writes files not declared as outputs.
+
+**Unexpected reads** are one of:
+
+1. **Missing input** (most likely) — the process legitimately needs this file. Understand what the process does and why the access makes sense, then declare it as an input.
+2. **Potential sandboxing gap** (last resort) — the access is irrelevant to correctness and should be filtered/ignored by the sandbox. Only conclude this after exhausting every possibility for it being a missing input.
+
+**Unexpected writes** follow the same logic:
+
+1. **Missing output** (most likely) — the process legitimately produces this file.
+2. **Potential sandboxing gap** (last resort) — same as above.
+
+The default assumption is that an unexpected access IS a missing declaration. The investigation's job is to understand WHY the process accesses the file — not to find reasons it shouldn't.
+
+## Critical Rules
+
+1. **NEVER read the sandbox report JSON directly** — these files are too large for the Read tool (50K+ tokens). Do NOT use `Read`, `cat`, `head`, `python3`, or `jq` on the raw report. All report parsing is handled by the script.
+2. **ALWAYS run the context-gathering script as the very first step** — no manual parsing, no ad-hoc python/jq on the report file. The script does everything deterministically.
+3. If the script fails, **report the error and stop**. Do not attempt manual parsing as a fallback.
+4. **Identify the inferring plugin BEFORE proposing any fix** — check `inference.plugin` in the script output or run `jq '.targets.<target>.metadata' <detail-file>`. Fixing the wrong plugin wastes entire investigation rounds.
+5. **Verify hypotheses empirically before committing to them** — see Principle 4 and the Phase 2 instrumentation guidance.
+
+## Workflow
+
+### Phase 0: Input
+
+User provides one of:
+
+- Path to a sandbox report JSON file
+- A URL to a sandbox report — pass it directly to the script, it handles downloading
+- A task ID + CIPE URL (fetch report via MCP if available)
+- Inline violation data
+
+If a task ID is provided but no report, ask the user for the report file.
+
+**Filtering**: Most invocations will focus on specific files, not the entire report. The user may specify:
+
+- A single file: `e2e.log`
+- A comma-separated list: `apps/nx-cloud/e2e.log,apps/nx-cloud/build/client/assets/main.js`
+- A glob pattern: `*.tsbuildinfo`, `apps/nx-cloud/build/**`
+- A directory prefix: `apps/nx-cloud/build/client/assets`
+
+When the user specifies files to focus on, pass them via `--filter` to the script. When they don't specify a filter and the report has many violations, summarize the groupings (by directory, extension) and ask which group(s) to investigate first rather than trying to investigate everything at once.
+
+### Phase 1: Deterministic Pre-Processing
+
+Run the context-gathering script **immediately** — this is the first tool call after reading the user's input.
+
+Call it exactly as shown — do NOT append `2>&1` or `2>/dev/null` (the script manages its own stderr internally). Run in the **foreground** (no `run_in_background`) with a **3-minute timeout** — reports can be large and the script runs the task + multiple nx commands:
+
+```bash
+npx tsx ${CLAUDE_SKILL_DIR}/scripts/gather-sandbox-context.ts <report.json or URL> [--filter <pattern>] [--workspace <path>]
+```
+
+Pass `--filter` when the user wants to focus on specific files or patterns. The script filters violations before all downstream processing (grouping, validation, classification), so the output only contains relevant data.
+
+The script produces two outputs:
+
+**stdout** (~3-5KB compact brief) — everything needed to start investigating:
+
+- `summary`: violation counts (total, filtered, confirmed vs undeclared)
+- `undeclaredFiles`: the actual file paths that are true violations
+- `grouping`: violations grouped by directory and extension
+- `commands`: processes with violations (pid, cmd, executable, arguments, counts) — no full file lists
+- `classificationSummary`: counts per category (cross-project, build artifacts, config files, etc.)
+- `crossProjectDependencyCheck`: whether cross-project file owners are in the task's dependency chain
+- `staleDeclarations`: grouped analysis of expectedInputsNotRead / expectedOutputsNotWritten
+- `dependentTasksOutputFiles`: extracted from target inputs config and named inputs — shows what dep output globs are declared (critical for cross-project violations)
+- `executorInfo`: executor name and resolved source path in `node_modules` — read this file to understand how the tool is invoked
+- `checkSample`: results of `--check` on up to 5 undeclared files (catches false positives early)
+- `inference` + `pluginRegistration`: plugin metadata
+- `verificationCommands`: pre-built `--check` commands with the correct task ref
+- `detailFile`: path to the full detail JSON
+
+**detail file** (`/tmp/sandbox-diagnosis-detail-<project>-<target>.json`) — full data for drill-down. Structure:
+
+- `processTree.processTree`: array of `{pid, cmd, parentPid}` entries
+- `processTree.processPidToCmd`: `{ "pid": "command string" }` map
+- `processTree.readsByPid`: `{ "pid": ["file1", "file2"] }` — violated reads grouped by PID
+- `processTree.writesByPid`: `{ "pid": ["file1", "file2"] }` — violated writes grouped by PID
+- `targetConfig`: full target configuration (executor, options, inputs, outputs, dependsOn)
+- `projectConfig`: full project configuration
+- `resolvedInputs`: `{ files: [...], depOutputs: [...], runtime: [...], environment: [...] }`
+- `resolvedOutputs`: `{ outputPaths: [...], expandedOutputs: [...] }`
+- `validation`: `{ reads: { confirmed: [...], undeclared: [...] }, writes: { ... } }`
+- `classification`: `{ reads: { crossProject, buildArtifacts, configFiles, ... }, writes: { ... } }`
+
+Read the brief output — it has everything to start. Use `jq` on the detail file only when you need to drill into specific sections. When querying the detail file, use the structure above — do not guess the schema. Do NOT use Python, ad-hoc scripts, or the Read tool on the detail file — only `jq`.
+
+For reports with many violations, use `--filter` to narrow scope. When investigating without a filter, use the `grouping` data to identify patterns and prioritize — don't try to trace every file individually.
+
+If `summary.undeclaredReads` and `summary.undeclaredWrites` are both 0, all violations were resolved by the script's validation against resolved inputs/outputs. Report this to the user — no further investigation needed.
+
+The `commands` array pre-parses each process — use `executable` and `arguments` to identify the tool without re-parsing `cmd`. When many files share the same root cause, group them under one finding using a glob pattern or count (e.g., "88 `.d.ts` files matching `packages/nx/dist/**/*.d.ts`").
+
+### Phase 2: Command Analysis — the core investigation
+
+**This is the most important phase.** The goal is to determine with 100% certainty why each process reads or writes each violated file. Do not classify violations from file names or paths alone — trace the actual causal chain from command → config → file access.
+
+#### Step 1: Understand the command
+
+The brief's `commands` array pre-parses each process. Use the `executable` and `arguments` fields directly — don't re-parse `cmd`. Identify:
+
+- The tool (from `executable`)
+- The arguments (target files/dirs, config flags, extensions — from `arguments`)
+- The working directory (from executor options or project root)
+
+#### Step 2: Trace why the command accesses each violated file
+
+For each violated file, establish the **exact causal chain** that leads the command to read or write it. The approach is the same regardless of tool:
+
+1. Identify the tool's config file (usually in the project root or workspace root)
+2. Read the config and trace file references: `includes`, `extends`, `presets`, entry points, plugins
+3. Follow the reference chain until you can explain exactly why the violated file is accessed
+
+Common causal patterns:
+
+- **Config chain walk-up**: tool reads config, config extends another, chain reaches the violated file (e.g., tsconfig `extends`, eslint config chain, jest preset chain)
+- **Directory traversal**: tool scans a directory for matching files and reads everything, including files it won't process (e.g., jest-haste-map scanning `.next/`, eslint reading `.d.ts` alongside `.ts`)
+- **Dependency resolution**: tool resolves imports/requires and follows the dependency graph to files outside the project (e.g., esbuild/vite/webpack resolving workspace packages to their dist outputs)
+- **Plugin/transformer loading**: tool loads plugins or transformers that read additional files (e.g., ts-jest loading tsconfig for TypeScript compilation)
+
+For any tool, read its source code in `node_modules` to understand its file discovery behavior. Don't assume — trace the actual code.
+
+**You must be able to explain the full path:** e.g., "eslint loads `.eslintrc.json` → configures `@typescript-eslint/parser` → parser resolves `parserOptions.project` → walks up to find `tsconfig.json` → reads it." If you can't trace the full path, keep investigating — do not guess.
+
+**When theoretical analysis is inconclusive, verify empirically.** For difficult cases, instrument `node_modules` with interceptors to capture real stack traces. For example, patch `fs.readFileSync` in the tool's entry point to log stack traces when the violated file is accessed. A confirmed stack trace is worth more than multiple rounds of code reading.
+
+#### Step 3: Confirm the violation with `--check`
+
+**This step is mandatory — do not skip it.** The script already runs `--check` on a sample of up to 5 undeclared files (see `checkSample` in the brief). Review those results first — if the sample files are confirmed as inputs/outputs, the corresponding violations are false positives.
+
+For files not in the sample, use the pre-generated commands from `verificationCommands` in the brief:
+
+```bash
+npx nx show target inputs <project>:<target> --check <violated-read-files>
+npx nx show target outputs <project>:<target> --check <violated-write-files>
+```
+
+If the commands fail because output files don't exist (e.g., the script's task run timed out), run the task first with `verificationCommands.runTask`.
+
+If `--check` shows the file IS already an input/output, the violation is a false positive from the script's static analysis. If it confirms the file is NOT an input/output, proceed to classification.
+
+#### Step 4: Classify
+
+With the causal chain established and the violation confirmed, classify into one of these categories:
+
+1. **Missing input/output** (most common) — the process legitimately needs this file. Understand why:
+   - **Direct dependency** — the tool needs this file to do its job (e.g., tsc reads referenced tsconfigs, eslint loads config chain)
+   - **Transitive dependency** — a config file references another file that references this one (e.g., jest preset → resolver → module). Trace the full chain.
+   - **Directory traversal side effect** — the tool reads all files in a directory even if it only processes some (e.g., eslint reads `.d.ts` files while linting `.ts`). Still a legitimate access from the tool's perspective.
+
+2. **Bad tool configuration** — the tool accesses a file it shouldn't because its scope is too broad. The fix is fixing the tool's config, NOT adding an input. Investigate:
+   - Is the command targeting too broad a directory? (e.g., `eslint .` instead of `eslint src/`)
+   - Is a config file missing ignore/exclude rules? (e.g., eslint processing a file type it should skip)
+   - Is a plugin inferring a target for a project that doesn't match? (e.g., eslint target on a non-JS project)
+   - Is an env var causing the tool to behave differently?
+
+3. **Potential sandboxing gap** (last resort) — the access is genuinely irrelevant to correctness (PID files, temp sockets, dev server logs that no task consumes). Only conclude this after exhausting categories 1 and 2.
+
+### Phase 3: Deep Investigation
+
+For violations that aren't immediately obvious, investigate further:
+
+#### If the target is inferred by a plugin
+
+1. Identify which plugin from `inference.plugin` in the brief output, or `nx show project --json` metadata
+2. Read the plugin's `createNodesV2` implementation to understand inference logic
+3. Determine if this project should have this target at all
+4. Check if the plugin has `include`/`exclude` patterns in `nx.json` that should filter this project
+5. **Check for input override layers** — `project.json`, `package.json`, or `nx.json` `targetDefaults` may override plugin-inferred inputs, rendering plugin-level fixes invisible. Check all three before concluding a plugin fix is sufficient.
+
+#### If violations come from a subprocess
+
+1. Trace the process tree: which parent spawned the subprocess?
+2. Why does the subprocess exist? (dev server for e2e, worker thread, build tool subprocess)
+3. What environment does the subprocess inherit? (env vars, cwd)
+4. Does the subprocess access files in a different project's directory?
+
+#### If violations involve config file reference chains
+
+1. Read the config file (jest.config, tsconfig, .eslintrc)
+2. Trace all file references: `preset`, `extends`, `references`, `setupFiles`, `resolver`, `moduleNameMapper`, `transform`, etc.
+3. Recursively resolve references (preset → preset → files)
+4. Determine which referenced files are not declared as task inputs
+
+#### If violations involve dependency task outputs
+
+1. Check `dependsOn` to understand task dependency chain
+2. Check `dependentTasksOutputFiles` glob pattern — is it too narrow?
+3. Compare the glob against actual file types the tool reads from dependencies (e.g., `**/*.d.ts` missing `.tsbuildinfo`)
+
+#### Generalizability analysis
+
+After diagnosing the root cause, determine scope:
+
+1. Is this violation specific to this project, or does it affect all projects using this tool/plugin?
+2. What conditions trigger it? (specific config, specific tool version, specific project structure)
+3. Should the fix be per-project (declarative input) or systemic (plugin improvement)?
+4. If the plugin can be made smarter to infer the correct inputs, that's preferable to manual declarations.
+
+### Phase 4: Output
+
+**You MUST present findings using the structured format below before proceeding to any implementation discussion.** Do not use free-form narrative — the structure ensures completeness and makes findings reviewable.
+
+Present findings grouped by category:
+
+```
+=== Sandbox Violation Diagnosis: {project}:{target} ===
+
+## Summary
+Unexpected reads:  N total → M validated as declared → K true violations
+Unexpected writes: N total → M validated as declared → K true violations
+
+## Findings
+
+### [MISSING INPUT] {short description}
+Files: {file list or pattern}
+Process: PID {pid} — {command}
+Why: {why the process legitimately needs this file}
+Scope: {project-specific or affects all projects using this tool/plugin}
+Fix: {where/how to add the input declaration — consider both declarative (add input) and systemic (improve plugin inference) options}
+
+### [MISSING OUTPUT] {short description}
+Files: {file list or pattern}
+Process: PID {pid} — {command}
+Why: {why the process produces this file}
+Scope: {project-specific or affects all projects using this tool/plugin}
+Fix: {where/how to add the output declaration}
+
+### [BAD TOOL CONFIG] {short description}
+Files: {file list or pattern}
+Process: PID {pid} — {command}
+Why: {why the tool accesses files it shouldn't — config too broad, missing ignore, etc.}
+Fix: {specific tool config change}
+
+### [POTENTIAL SANDBOXING GAP] {short description}
+Files: {file list or pattern}
+Process: PID {pid} — {command}
+Why: {why this access is irrelevant to correctness}
+Evidence: {proof that categories 1-2 were exhausted}
+
+### [INVESTIGATE] {short description}
+Files: {file list or pattern}
+Notes: {what's known, what needs more info}
+Question: {what to ask the user or team}
+
+## Stale Declarations
+expectedInputsNotRead: {count and details if relevant}
+expectedOutputsNotWritten: {count and details if relevant}
+
+## Verification Plan
+For each fix, provide the exact commands to verify:
+1. Run the task so output files exist on disk: `npx nx <target> <project> --skip-nx-cache`
+2. Check each violation file is now an input: `npx nx show target <project>:<target> inputs --check <space-separated files>`
+3. For plugin-level fixes: build the plugin, patch node_modules, then verify with steps 1-2
+```
+
+## Principles
+
+1. **Missing declaration is the default.** Most unexpected accesses are legitimate — the process needs the file, it just wasn't declared. Start from this assumption and investigate to understand WHY the access happens.
+2. **The command is the unit of analysis.** Don't classify files in isolation. Understand what the command does and whether each file access makes sense given that command's purpose.
+3. **Trace the full chain.** Plugin inference → target config → executor → command → file access. The root cause is often several layers removed from the symptom.
+4. **Empirical over theoretical.** When code analysis produces a hypothesis, verify it before acting. Instrument `node_modules`, capture stack traces, run with debug flags. Wrong theories waste entire investigation rounds.
+5. **Be thorough.** Read plugin source code, config files, executor implementations. Don't guess based on file names alone.
+6. **Potential sandboxing gaps are last resort.** Only conclude this after exhausting missing declaration and bad tool config. The access must be genuinely irrelevant to correctness.
+7. **Verify claims about Nx behavior in source code.** Any assertion about how Nx works must be traced to the actual implementation. Do not reason from theory or assumptions.
+8. **Prefer systemic fixes over per-project declarations.** If a plugin can be improved to infer correct inputs for all projects, that's better than adding manual input declarations to each project.
+
+## Delegating to Subagents
+
+When the investigation is complex and requires parallel research, you can delegate to subagents. Follow this pattern:
+
+1. **Run the context-gathering script yourself first.** The brief output (~3-5KB) is the shared context all subagents need.
+2. **Include the brief output in each subagent prompt** along with the specific question to investigate. Subagents should NOT run the script again or try to parse the raw report.
+3. **Give subagents the detail file path** so they can `jq` specific sections (process tree, resolved inputs, etc.) without re-running the script.
+4. **Each subagent should answer one focused question**, e.g., "Why does PID 12345 (eslint) read `tsconfig.base.json`? Trace the full causal chain from the eslint config."
+5. **Subagents must still follow the skill principles** — trace full causal chains, verify empirically, use `--check`, don't guess from file names. Include these instructions in the subagent prompt.
+6. **Synthesize subagent results yourself** using the structured Phase 4 output format. Do not delegate the final classification.
+
+## Reference
+
+For the sandbox report data model and field definitions, see `references/data-model.md`.

.claude/disabled-skills/diagnose-sandbox-report/references/data-model.md

@@ -0,0 +1,92 @@
+# Sandbox Report Data Model
+
+## Raw Report Structure (JSON)
+
+```typescript
+interface SandboxReport {
+  taskId: string; // "project:target" or "project:target:configuration"
+  sandboxReportId: string;
+  inputs: string[]; // declared input patterns (globs or paths)
+  outputs: string[]; // declared output patterns
+  filesRead: FileAccessEntry[]; // all files actually read
+  filesWritten: FileAccessEntry[]; // all files actually written
+  unexpectedReads?: FileAccessEntry[]; // reads not matching any input pattern
+  unexpectedWrites?: FileAccessEntry[]; // writes not matching any output pattern
+  expectedInputsNotRead?: string[]; // declared inputs never accessed
+  expectedOutputsNotWritten?: string[]; // declared outputs never written
+  processTree?: ProcessTreeEntry[]; // process hierarchy with commands
+}
+
+interface FileAccessEntry {
+  path: string; // workspace-relative file path
+  pid: number; // process ID that accessed the file
+}
+
+interface ProcessTreeEntry {
+  pid: number;
+  cmd: string; // full command string
+  parentPid?: number; // parent process (absent for root)
+}
+```
+
+## Violation Computation
+
+Violations are computed by `findUnexpectedFiles()` using `minimatch`:
+
+- A file is "unexpected" if it does NOT match any declared pattern
+- Patterns without wildcards also match as directory prefixes (`pattern + '/'`)
+- If `unexpectedReads`/`unexpectedWrites` are pre-computed in the report, those are used directly
+
+## Nx CLI Commands for Context
+
+### `nx show target <project:target> --json`
+
+Returns: executor, command, options (merged with configuration), inputs (configured, not resolved), outputs, dependsOn, cache, parallelism, configurations, metadata.
+
+### `nx show target inputs <project:target> --json`
+
+Returns resolved input files (requires files to exist on disk — task must have run):
+
+```json
+{
+  "files": ["workspace-relative paths..."],
+  "runtime": ["node version checks..."],
+  "environment": ["ENV_VAR_NAMES..."],
+  "depOutputs": ["dependency output paths..."],
+  "external": ["external package names..."]
+}
+```
+
+### `nx show target inputs <project:target> --check <files...>`
+
+Validates specific files against declared inputs. Exit code 0 = match, 1 = no match.
+Categories: `files`, `environment`, `runtime`, `external`, `depOutputs`.
+Also detects directory matches (directory containing N input files).
+
+### `nx show target outputs <project:target> --json`
+
+Returns:
+
+```json
+{
+  "outputPaths": ["configured output paths..."],
+  "expandedOutputs": ["glob-expanded actual paths..."],
+  "unresolvedOutputs": ["{options.key} patterns that couldn't resolve..."]
+}
+```
+
+### `nx show target outputs <project:target> --check <files...>`
+
+Validates specific files against declared outputs. Same exit code behavior as inputs.
+
+### `nx show project <project> --json`
+
+Returns full project config. Key fields for sandbox analysis:
+
+- `targets[name].metadata.plugin` — which plugin inferred the target
+- `targets[name].metadata.technologies` — what tech the target uses
+- `root` — project root directory
+
+### `nx graph --view=tasks --targets=<target> --focus=<project> --print --file=stdout`
+
+Returns task dependency graph with task IDs, dependencies, and roots.

.claude/disabled-skills/diagnose-sandbox-report/scripts/gather-sandbox-context.ts

@@ -0,0 +1,846 @@
+#!/usr/bin/env npx tsx
+/**
+ * gather-sandbox-context: Parse sandbox report + gather Nx task context
+ * Produces structured JSON for the diagnose-sandbox-report skill
+ *
+ * Usage: npx tsx gather-sandbox-context.ts <report.json or URL> [--filter <pattern>] [--workspace <path>]
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { resolve, basename, extname, dirname } from 'path';
+import { execSync, execFileSync } from 'child_process';
+import { minimatch } from 'minimatch';
+
+// --- CLI argument parsing ---
+
+interface Args {
+  reportFile: string;
+  filter: string | null;
+  workspaceRoot: string;
+}
+
+function parseArgs(): Args {
+  const args = process.argv.slice(2);
+  let reportFile = '';
+  let filter: string | null = null;
+  let workspaceRoot = process.cwd();
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--filter':
+        filter = args[++i];
+        break;
+      case '--workspace':
+        workspaceRoot = args[++i];
+        break;
+      case '--help':
+      case '-h':
+        console.error(
+          'Usage: gather-sandbox-context <report.json or URL> [--filter <pattern>] [--workspace <path>]'
+        );
+        process.exit(1);
+      default:
+        if (args[i].startsWith('-')) {
+          console.error(`Unknown option: ${args[i]}`);
+          process.exit(1);
+        }
+        reportFile = args[i];
+    }
+  }
+
+  if (!reportFile) {
+    console.error(
+      'Usage: gather-sandbox-context <report.json or URL> [--filter <pattern>] [--workspace <path>]'
+    );
+    process.exit(1);
+  }
+
+  return { reportFile, filter, workspaceRoot };
+}
+
+// --- Types ---
+
+interface FileAccessEntry {
+  path: string;
+  pid: number;
+}
+
+interface ProcessTreeEntry {
+  pid: number;
+  cmd: string;
+  parentPid?: number;
+}
+
+interface SandboxReport {
+  taskId: string;
+  unexpectedReads?: FileAccessEntry[];
+  unexpectedWrites?: FileAccessEntry[];
+  expectedInputsNotRead?: string[];
+  expectedOutputsNotWritten?: string[];
+  filesRead?: FileAccessEntry[];
+  filesWritten?: FileAccessEntry[];
+  processTree?: ProcessTreeEntry[];
+}
+
+// --- Helpers ---
+
+function downloadUrl(url: string): string {
+  const tmpPath = `/tmp/sandbox-report-${Date.now()}.json`;
+  try {
+    execFileSync('curl', ['-sL', '-o', tmpPath, url], { stdio: 'pipe' });
+  } catch {
+    console.error(`Error: Failed to download report from URL: ${url}`);
+    process.exit(1);
+  }
+  return tmpPath;
+}
+
+function runNxCommand(
+  args: string[],
+  workspaceRoot: string,
+  timeoutMs = 30000
+): string | null {
+  try {
+    return execFileSync('npx', ['nx', ...args], {
+      cwd: workspaceRoot,
+      timeout: timeoutMs,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+    });
+  } catch {
+    return null;
+  }
+}
+
+function safeJsonParse<T>(str: string | null, fallback: T): T {
+  if (!str) return fallback;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return fallback;
+  }
+}
+
+function filterEntries(
+  entries: FileAccessEntry[],
+  filterStr: string | null
+): FileAccessEntry[] {
+  if (!filterStr) return entries;
+
+  const patterns = filterStr.split(',').map((p) => p.trim());
+  return entries.filter((entry) =>
+    patterns.some((pattern) => {
+      if (
+        pattern.includes('*') ||
+        pattern.includes('?') ||
+        pattern.includes('[')
+      ) {
+        // Glob pattern — if no slashes, match against basename
+        if (!pattern.includes('/')) {
+          return minimatch(basename(entry.path), pattern);
+        }
+        return minimatch(entry.path, pattern);
+      }
+      // Literal: exact match or directory prefix
+      return entry.path === pattern || entry.path.startsWith(pattern + '/');
+    })
+  );
+}
+
+function groupByDirPrefix(
+  paths: string[],
+  depth = 3
+): { prefix: string; count: number }[] {
+  const groups: Record<string, number> = {};
+  for (const p of paths) {
+    const prefix = p.split('/').slice(0, depth).join('/');
+    groups[prefix] = (groups[prefix] || 0) + 1;
+  }
+  return Object.entries(groups)
+    .map(([prefix, count]) => ({ prefix, count }))
+    .sort((a, b) => b.count - a.count);
+}
+
+function groupByExtension(paths: string[]): { ext: string; count: number }[] {
+  const groups: Record<string, number> = {};
+  for (const p of paths) {
+    const ext = extname(p) || '(no ext)';
+    groups[ext] = (groups[ext] || 0) + 1;
+  }
+  return Object.entries(groups)
+    .map(([ext, count]) => ({ ext, count }))
+    .sort((a, b) => b.count - a.count);
+}
+
+function classifyFiles(
+  undeclared: string[],
+  projectRoot: string,
+  projectRoots: Record<string, string>
+) {
+  const projects = Object.entries(projectRoots).map(([project, root]) => ({
+    project,
+    root,
+  }));
+
+  const isBuildArtifact = (f: string) =>
+    f.startsWith('dist/') ||
+    f.startsWith('build/') ||
+    f.startsWith('out-tsc/') ||
+    f.startsWith('.next/') ||
+    f.includes('/node_modules/.cache/') ||
+    f.endsWith('.tsbuildinfo') ||
+    f.includes('/dist/') ||
+    f.includes('/build/output/');
+
+  const configBasenames = new Set(['nx.json', 'project.json', 'package.json']);
+  const configPrefixes = [
+    'tsconfig',
+    'jest.config',
+    'jest.preset',
+    '.eslintrc',
+    'eslint.config',
+    'playwright.config',
+    'webpack.config',
+    'vite.config',
+    'babel.config',
+    '.babelrc',
+    'rollup.config',
+  ];
+  const isConfigFile = (f: string) => {
+    const b = basename(f);
+    return (
+      configBasenames.has(b) ||
+      configPrefixes.some((prefix) => b.startsWith(prefix))
+    );
+  };
+
+  const isEnvFile = (f: string) => {
+    const b = basename(f);
+    return b === '.env' || b.startsWith('.env.');
+  };
+
+  const classified = undeclared.map((f) => {
+    const inProjectRoot = projectRoot !== '' && f.startsWith(projectRoot + '/');
+    const owner = projects.find((p) => f.startsWith(p.root + '/'));
+    return {
+      path: f,
+      inProjectRoot,
+      ownerProject: owner?.project ?? null,
+      isBuildArtifact: isBuildArtifact(f),
+      isConfigFile: isConfigFile(f),
+      isEnvFile: isEnvFile(f),
+    };
+  });
+
+  return {
+    crossProject: classified
+      .filter((c) => !c.inProjectRoot)
+      .map((c) => ({ path: c.path, owner: c.ownerProject })),
+    buildArtifacts: classified
+      .filter((c) => c.isBuildArtifact)
+      .map((c) => c.path),
+    configFiles: classified.filter((c) => c.isConfigFile).map((c) => c.path),
+    envFiles: classified.filter((c) => c.isEnvFile).map((c) => c.path),
+    inProjectRoot: classified.filter((c) => c.inProjectRoot).map((c) => c.path),
+    outsideProjectRoot: classified
+      .filter((c) => !c.inProjectRoot)
+      .map((c) => c.path),
+    total: undeclared.length,
+  };
+}
+
+function validateViolations(
+  violations: string[],
+  resolvedFiles: Set<string>
+): { confirmed: string[]; undeclared: string[] } {
+  const confirmed: string[] = [];
+  const undeclared: string[] = [];
+  const seen = new Set<string>();
+  for (const f of violations) {
+    if (seen.has(f)) continue;
+    seen.add(f);
+    if (resolvedFiles.has(f)) {
+      confirmed.push(f);
+    } else {
+      undeclared.push(f);
+    }
+  }
+  return { confirmed, undeclared };
+}
+
+function validateOutputViolations(
+  violations: string[],
+  resolvedOutputs: string[]
+): { confirmed: string[]; undeclared: string[] } {
+  const outputSet = new Set(resolvedOutputs);
+  const outputDirs = resolvedOutputs.map((o) => o + '/');
+  const confirmed: string[] = [];
+  const undeclared: string[] = [];
+  const seen = new Set<string>();
+  for (const f of violations) {
+    if (seen.has(f)) continue;
+    seen.add(f);
+    if (outputSet.has(f) || outputDirs.some((d) => f.startsWith(d))) {
+      confirmed.push(f);
+    } else {
+      undeclared.push(f);
+    }
+  }
+  return { confirmed, undeclared };
+}
+
+function extractCommands(
+  processTree: ProcessTreeEntry[],
+  readsByPid: Record<string, string[]>,
+  writesByPid: Record<string, string[]>
+) {
+  const pidToCmd: Record<string, string> = {};
+  for (const entry of processTree) {
+    pidToCmd[String(entry.pid)] = entry.cmd;
+  }
+
+  return processTree
+    .filter(
+      (entry) =>
+        (readsByPid[String(entry.pid)]?.length ?? 0) > 0 ||
+        (writesByPid[String(entry.pid)]?.length ?? 0) > 0
+    )
+    .map((entry) => {
+      const parts = entry.cmd.split(' ');
+      const exe = parts[0].split('/').pop() ?? parts[0];
+      return {
+        pid: entry.pid,
+        cmd: entry.cmd,
+        parentPid: entry.parentPid ?? null,
+        parentCmd: entry.parentPid
+          ? (pidToCmd[String(entry.parentPid)] ?? null)
+          : null,
+        unexpectedReadCount: readsByPid[String(entry.pid)]?.length ?? 0,
+        unexpectedWriteCount: writesByPid[String(entry.pid)]?.length ?? 0,
+        unexpectedReads: readsByPid[String(entry.pid)] ?? [],
+        unexpectedWrites: writesByPid[String(entry.pid)] ?? [],
+        executable: exe,
+        arguments: parts.slice(1).join(' '),
+      };
+    })
+    .sort(
+      (a, b) =>
+        b.unexpectedReadCount +
+        b.unexpectedWriteCount -
+        (a.unexpectedReadCount + a.unexpectedWriteCount)
+    );
+}
+
+function resolveExecutorSource(
+  executor: string | undefined,
+  workspaceRoot: string
+): { executor: string; sourcePath: string } {
+  if (
+    !executor ||
+    executor === 'null' ||
+    executor.includes('nx:run-commands')
+  ) {
+    return { executor: executor ?? '', sourcePath: '' };
+  }
+
+  const lastColon = executor.lastIndexOf(':');
+  const pkg = executor.substring(0, lastColon);
+  const name = executor.substring(lastColon + 1);
+
+  try {
+    const result = execFileSync(
+      'node',
+      [
+        '-e',
+        `
+      try {
+        const pkg = require('${pkg}/package.json');
+        const executors = pkg.executors || pkg.builders;
+        if (executors) {
+          const p = require.resolve('${pkg}/' + executors);
+          const dir = require('path').dirname(p);
+          const json = require(p);
+          const impl = json.executors?.['${name}']?.implementation ||
+                       json.builders?.['${name}']?.implementation;
+          if (impl) console.log(require.resolve(dir + '/' + impl));
+        }
+      } catch(e) {}
+    `,
+      ],
+      {
+        cwd: workspaceRoot,
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        timeout: 10000,
+      }
+    ).trim();
+    return { executor, sourcePath: result };
+  } catch {
+    return { executor, sourcePath: '' };
+  }
+}
+
+function extractDepTaskOutputFiles(
+  targetConfig: any,
+  workspaceRoot: string
+): { dependentTasksOutputFiles: any[]; namedInputs: string[] } {
+  const inputs: any[] = targetConfig?.inputs ?? [];
+  const depOutputs: any[] = [];
+  const namedInputs: string[] = [];
+
+  for (const input of inputs) {
+    if (
+      typeof input === 'object' &&
+      input !== null &&
+      'dependentTasksOutputFiles' in input
+    ) {
+      depOutputs.push({
+        glob: input.dependentTasksOutputFiles,
+        transitive: input.transitive ?? false,
+      });
+    } else if (
+      typeof input === 'string' &&
+      !input.startsWith('{') &&
+      !input.startsWith('^') &&
+      !input.includes('/') &&
+      !input.includes('.')
+    ) {
+      namedInputs.push(input);
+    }
+  }
+
+  // Resolve named inputs from nx.json
+  const nxJsonPath = resolve(workspaceRoot, 'nx.json');
+  if (existsSync(nxJsonPath) && namedInputs.length > 0) {
+    try {
+      const nxJson = JSON.parse(readFileSync(nxJsonPath, 'utf-8'));
+      for (const name of namedInputs) {
+        const namedDef = nxJson.namedInputs?.[name] ?? [];
+        for (const entry of namedDef) {
+          if (
+            typeof entry === 'object' &&
+            entry !== null &&
+            'dependentTasksOutputFiles' in entry
+          ) {
+            depOutputs.push({
+              glob: entry.dependentTasksOutputFiles,
+              transitive: entry.transitive ?? false,
+              fromNamedInput: name,
+            });
+          }
+        }
+      }
+    } catch {
+      // ignore nx.json parse errors
+    }
+  }
+
+  return { dependentTasksOutputFiles: depOutputs, namedInputs };
+}
+
+function analyzeStaleDeclarations(
+  expectedInputsNotRead: string[],
+  expectedOutputsNotWritten: string[]
+) {
+  const classifyPattern = (value: string) => {
+    if (/[*{]/.test(value)) return 'glob';
+    if (value.startsWith('^')) return 'depOutput';
+    return 'file';
+  };
+
+  const groupByType = (items: string[]) => {
+    const groups: Record<string, string[]> = {};
+    for (const item of items) {
+      const type = classifyPattern(item);
+      (groups[type] ??= []).push(item);
+    }
+    return Object.entries(groups).map(([type, values]) => ({
+      type,
+      count: values.length,
+      samples: values.slice(0, 3),
+    }));
+  };
+
+  return {
+    expectedInputsNotRead: expectedInputsNotRead.length,
+    expectedOutputsNotWritten: expectedOutputsNotWritten.length,
+    staleInputsByType: groupByType(expectedInputsNotRead),
+    staleOutputsByType: groupByType(expectedOutputsNotWritten),
+  };
+}
+
+// --- Main ---
+
+async function main() {
+  const args = parseArgs();
+  let reportPath = args.reportFile;
+
+  // Handle URL inputs
+  if (reportPath.startsWith('http')) {
+    reportPath = downloadUrl(reportPath);
+  }
+
+  if (!existsSync(reportPath)) {
+    console.error(`Error: Report file not found: ${reportPath}`);
+    process.exit(1);
+  }
+
+  reportPath = resolve(reportPath);
+  process.chdir(args.workspaceRoot);
+
+  // Phase 1: Parse report (single read)
+  let report: SandboxReport;
+  try {
+    report = JSON.parse(readFileSync(reportPath, 'utf-8'));
+  } catch {
+    console.error(`Error: Report file is not valid JSON: ${reportPath}`);
+    process.exit(1);
+  }
+
+  if (!report.taskId) {
+    console.error('Error: Report file has no .taskId field');
+    process.exit(1);
+  }
+
+  const [project, target, config] = report.taskId.split(':');
+  const taskRef = config
+    ? `${project}:${target}:${config}`
+    : `${project}:${target}`;
+
+  const unexpectedReads = report.unexpectedReads ?? [];
+  const unexpectedWrites = report.unexpectedWrites ?? [];
+
+  // Apply filter
+  const filteredReads = filterEntries(unexpectedReads, args.filter);
+  const filteredWrites = filterEntries(unexpectedWrites, args.filter);
+
+  const readPaths = filteredReads.map((e) => e.path);
+  const writePaths = filteredWrites.map((e) => e.path);
+
+  // Build pid → files maps
+  const readsByPid: Record<string, string[]> = {};
+  const writesByPid: Record<string, string[]> = {};
+  for (const entry of filteredReads) {
+    (readsByPid[String(entry.pid)] ??= []).push(entry.path);
+  }
+  for (const entry of filteredWrites) {
+    (writesByPid[String(entry.pid)] ??= []).push(entry.path);
+  }
+
+  // Phase 2: Gather Nx task context (run task + parallel nx commands)
+  runNxCommand(['run', taskRef], args.workspaceRoot, 120000);
+
+  const [
+    targetConfigStr,
+    projectConfigStr,
+    resolvedInputsStr,
+    resolvedOutputsStr,
+    graphResult,
+  ] = await Promise.all([
+    runNxCommand(['show', 'target', taskRef, '--json'], args.workspaceRoot),
+    runNxCommand(['show', 'project', project, '--json'], args.workspaceRoot),
+    runNxCommand(
+      ['show', 'target', 'inputs', taskRef, '--json'],
+      args.workspaceRoot
+    ),
+    runNxCommand(
+      ['show', 'target', 'outputs', taskRef, '--json'],
+      args.workspaceRoot
+    ),
+    (() => {
+      const graphPath = `/tmp/sandbox-project-graph-${Date.now()}.json`;
+      runNxCommand(['graph', '--file', graphPath], args.workspaceRoot);
+      try {
+        return readFileSync(graphPath, 'utf-8');
+      } catch {
+        return '{"graph":{"nodes":{}}}';
+      }
+    })(),
+  ]);
+
+  const targetConfig = safeJsonParse(targetConfigStr, {} as any);
+  const projectConfig = safeJsonParse(projectConfigStr, {} as any);
+  const resolvedInputs = safeJsonParse(resolvedInputsStr, {} as any);
+  const resolvedOutputs = safeJsonParse(resolvedOutputsStr, {} as any);
+  const projectGraph = safeJsonParse(graphResult, {
+    graph: { nodes: {} },
+  } as any);
+
+  // Phase 3: Validate violations
+  const resolvedInputFiles = new Set([
+    ...(resolvedInputs.files ?? []),
+    ...(resolvedInputs.depOutputs ?? []),
+  ]);
+  const resolvedOutputFiles = [
+    ...(resolvedOutputs.outputPaths ?? []),
+    ...(resolvedOutputs.expandedOutputs ?? []),
+  ];
+
+  const checkInputs = validateViolations(readPaths, resolvedInputFiles);
+  const checkOutputs = validateOutputViolations(
+    writePaths,
+    resolvedOutputFiles
+  );
+
+  // Phase 3.5: Sample --check verification
+  let checkSampleInputs: any = {};
+  let checkSampleOutputs: any = {};
+  const sampleReadFiles = checkInputs.undeclared.slice(0, 5);
+  if (sampleReadFiles.length > 0) {
+    const result = runNxCommand(
+      [
+        'show',
+        'target',
+        'inputs',
+        taskRef,
+        '--check',
+        ...sampleReadFiles,
+        '--json',
+      ],
+      args.workspaceRoot
+    );
+    checkSampleInputs = safeJsonParse(result, {});
+  }
+  const sampleWriteFiles = checkOutputs.undeclared.slice(0, 5);
+  if (sampleWriteFiles.length > 0) {
+    const result = runNxCommand(
+      [
+        'show',
+        'target',
+        'outputs',
+        taskRef,
+        '--check',
+        ...sampleWriteFiles,
+        '--json',
+      ],
+      args.workspaceRoot
+    );
+    checkSampleOutputs = safeJsonParse(result, {});
+  }
+
+  // Phase 4: File classification
+  const projectRoots: Record<string, string> = {};
+  for (const [name, node] of Object.entries(projectGraph.graph?.nodes ?? {})) {
+    projectRoots[name] = (node as any).data?.root ?? name;
+  }
+  const taskProjectRoot = projectRoots[project] ?? '';
+
+  const readClassification = classifyFiles(
+    checkInputs.undeclared,
+    taskProjectRoot,
+    projectRoots
+  );
+  const writeClassification = classifyFiles(
+    checkOutputs.undeclared,
+    taskProjectRoot,
+    projectRoots
+  );
+
+  // Phase 5: Command extraction
+  const processTree = report.processTree ?? [];
+  const commands = extractCommands(processTree, readsByPid, writesByPid);
+
+  // Phase 6: Inference detection
+  const targetMeta = projectConfig.targets?.[target]?.metadata ?? {};
+  const inference = {
+    isInferred: 'plugin' in targetMeta || 'technologies' in targetMeta,
+    plugin: targetMeta.plugin ?? null,
+    technologies: targetMeta.technologies ?? null,
+    description: targetMeta.description ?? null,
+  };
+
+  let pluginRegistration: any = {};
+  const nxJsonPath = resolve(args.workspaceRoot, 'nx.json');
+  if (inference.plugin && existsSync(nxJsonPath)) {
+    try {
+      const nxJson = JSON.parse(readFileSync(nxJsonPath, 'utf-8'));
+      const plugins = (nxJson.plugins ?? []).map((p: any) =>
+        typeof p === 'string' ? { plugin: p, options: {} } : p
+      );
+      pluginRegistration =
+        plugins.find((p: any) => p.plugin === inference.plugin) ?? {};
+    } catch {
+      // ignore
+    }
+  }
+
+  // Phase 6.5: dependentTasksOutputFiles + executor resolution
+  const depTaskOutputs = extractDepTaskOutputFiles(
+    targetConfig,
+    args.workspaceRoot
+  );
+  const executorInfo = resolveExecutorSource(
+    targetConfig.executor ?? targetConfig.command,
+    args.workspaceRoot
+  );
+
+  // Phase 7: Cross-project dependency check
+  const dependsOn = (targetConfig.dependsOn ?? []).map((d: any) =>
+    typeof d === 'string' ? d : (d.target ?? '')
+  );
+  const checkCrossProject = (classification: typeof readClassification) => {
+    const owners = [
+      ...new Set(
+        classification.crossProject
+          .map((c) => c.owner)
+          .filter((o): o is string => o !== null)
+      ),
+    ];
+    return owners.map((owner) => ({
+      project: owner,
+      isDependency: dependsOn.some(
+        (d: string) =>
+          d === owner ||
+          d === `${owner}:build` ||
+          d === `^${owner}:build` ||
+          d.includes(`^${owner}`)
+      ),
+      files: classification.crossProject
+        .filter((c) => c.owner === owner)
+        .map((c) => c.path),
+    }));
+  };
+
+  const crossProjectDeps = {
+    reads: checkCrossProject(readClassification),
+    writes: checkCrossProject(writeClassification),
+  };
+
+  // Phase 8: Stale declarations
+  const staleDeclarations = analyzeStaleDeclarations(
+    report.expectedInputsNotRead ?? [],
+    report.expectedOutputsNotWritten ?? []
+  );
+
+  // Assemble outputs
+  const detailFile = `/tmp/sandbox-diagnosis-detail-${taskRef.replace(/[/:@]/g, '-')}.json`;
+
+  const detail = {
+    processTree: {
+      processTree,
+      processPidToCmd: Object.fromEntries(
+        processTree.map((e) => [String(e.pid), e.cmd])
+      ),
+      readsByPid,
+      writesByPid,
+    },
+    targetConfig,
+    projectConfig,
+    resolvedInputs,
+    resolvedOutputs,
+    validation: { reads: checkInputs, writes: checkOutputs },
+    classification: { reads: readClassification, writes: writeClassification },
+    report: {
+      taskId: report.taskId,
+      totalFilesRead: report.filesRead?.length ?? 0,
+      totalFilesWritten: report.filesWritten?.length ?? 0,
+      totalUnexpectedReads: unexpectedReads.length,
+      totalUnexpectedWrites: unexpectedWrites.length,
+      expectedInputsNotRead: report.expectedInputsNotRead ?? [],
+      expectedOutputsNotWritten: report.expectedOutputsNotWritten ?? [],
+    },
+    commands,
+    crossProjectDependencyCheck: crossProjectDeps,
+    staleDeclarations,
+    inference,
+    pluginRegistration,
+    dependentTasksOutputFiles: depTaskOutputs,
+    executorInfo,
+  };
+  writeFileSync(detailFile, JSON.stringify(detail, null, 2));
+
+  // Brief to stdout
+  const brief = {
+    task: {
+      ref: taskRef,
+      project,
+      target,
+      configuration: config ?? null,
+      projectRoot: taskProjectRoot,
+    },
+    summary: {
+      unexpectedReads: unexpectedReads.length,
+      unexpectedWrites: unexpectedWrites.length,
+      filteredReads: filteredReads.length,
+      filteredWrites: filteredWrites.length,
+      filterApplied: args.filter !== null,
+      filterPattern: args.filter,
+      confirmedReads: checkInputs.confirmed.length,
+      undeclaredReads: checkInputs.undeclared.length,
+      confirmedWrites: checkOutputs.confirmed.length,
+      undeclaredWrites: checkOutputs.undeclared.length,
+    },
+    undeclaredFiles: {
+      reads: checkInputs.undeclared,
+      writes: checkOutputs.undeclared,
+    },
+    grouping: {
+      readsByDirectory: groupByDirPrefix(readPaths),
+      writesByDirectory: groupByDirPrefix(writePaths),
+      byExtension: {
+        readsByExt: groupByExtension(readPaths),
+        writesByExt: groupByExtension(writePaths),
+      },
+    },
+    commands: commands.map(
+      ({
+        pid,
+        cmd,
+        parentCmd,
+        executable,
+        arguments: args,
+        unexpectedReadCount,
+        unexpectedWriteCount,
+      }) => ({
+        pid,
+        cmd,
+        parentCmd,
+        executable,
+        arguments: args,
+        unexpectedReadCount,
+        unexpectedWriteCount,
+      })
+    ),
+    checkSample: {
+      inputs: checkSampleInputs,
+      outputs: checkSampleOutputs,
+    },
+    classificationSummary: {
+      reads: {
+        crossProject: readClassification.crossProject.length,
+        buildArtifacts: readClassification.buildArtifacts.length,
+        configFiles: readClassification.configFiles.length,
+        envFiles: readClassification.envFiles.length,
+        inProjectRoot: readClassification.inProjectRoot.length,
+        outsideProjectRoot: readClassification.outsideProjectRoot.length,
+      },
+      writes: {
+        crossProject: writeClassification.crossProject.length,
+        buildArtifacts: writeClassification.buildArtifacts.length,
+        configFiles: writeClassification.configFiles.length,
+        envFiles: writeClassification.envFiles.length,
+        inProjectRoot: writeClassification.inProjectRoot.length,
+        outsideProjectRoot: writeClassification.outsideProjectRoot.length,
+      },
+    },
+    crossProjectDependencyCheck: crossProjectDeps,
+    staleDeclarations,
+    dependentTasksOutputFiles: depTaskOutputs.dependentTasksOutputFiles,
+    executorInfo,
+    inference,
+    pluginRegistration,
+    verificationCommands: {
+      checkInputs: `npx nx show target inputs ${taskRef} --check <files...>`,
+      checkOutputs: `npx nx show target outputs ${taskRef} --check <files...>`,
+      runTask: `npx nx run ${taskRef} --skip-nx-cache`,
+    },
+    detailFile,
+  };
+
+  console.log(JSON.stringify(brief, null, 2));
+}
+
+main().catch((err) => {
+  console.error(`Script failed: ${err.message}`);
+  process.exit(1);
+});

.claude/settings.json

@@ -30,5 +30,17 @@
   "enableAllProjectMcpServers": true,
   "env": {
     "BASH_MAX_TIMEOUT_MS": "1800000"
+  },
+  "extraKnownMarketplaces": {
+    "nx-claude-plugins": {
+      "source": {
+        "source": "github",
+        "repo": "nrwl/nx-ai-agents-config",
+        "ref": "experimental"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "nx@nx-claude-plugins": true
   }
 }

.claude/skills/dist-build-migration/SKILL.md

@@ -0,0 +1,590 @@
+---
+name: dist-build-migration
+description: Migrate an Nx package to build to a local dist/ directory with nodenext module resolution, exports map, and @nx/nx-source condition.
+allowed-tools: Bash, Read, Glob, Grep, Agent, Edit, Write
+---
+
+# Migrate Package to Local Dist Build
+
+You are migrating an Nx monorepo package from building to `../../dist/packages/<name>` to building locally to `packages/<name>/dist/`. This matches the pattern already used by `nx` and `devkit`.
+
+## Argument
+
+The user provides a package name (e.g., `js`, `webpack`, `angular`). The package lives at `packages/<name>/`.
+
+## Steps
+
+### 0. Preflight: check `workspace:*` deps for unmigrated packages
+
+Read `packages/<name>/package.json` and list every `workspace:*` dep (in `dependencies`, `devDependencies`, `peerDependencies`).
+
+For each such dep, look at the target package's `project.json`. If it does **not** override `release.version.manifestRootsToUpdate` to `["packages/{projectName}"]`, that target package is still on the old layout. You **must** migrate those packages too (apply this skill to each), in the same PR.
+
+**Why:** With `preserveLocalDependencyProtocols: true` (the new pattern), `nx release version` does not substitute `workspace:*` in your manifest. At publish time, pnpm resolves `workspace:*` by reading the target's _source_ `packages/<dep>/package.json`. The default `manifestRootsToUpdate: ["dist/packages/{projectName}"]` only bumps the dist copy, so pnpm picks up the unbumped source `0.0.1` and publishes your package with a dep on a version that does not exist in the registry. Local registry installs then fail with `ERR_PNPM_NO_MATCHING_VERSION`.
+
+A `workspace:*` dep on a still-on-old-layout package is a hard blocker — migrate it before continuing.
+
+### 1. Read current state
+
+Read these files for the target package:
+
+- `packages/<name>/package.json`
+- `packages/<name>/project.json`
+- `packages/<name>/tsconfig.lib.json`
+- `packages/<name>/tsconfig.spec.json` (if exists)
+- `packages/<name>/.eslintrc.json` (if exists)
+- `packages/<name>/assets.json` (if exists)
+- `packages/<name>/.npmignore` (if exists)
+- `packages/<name>/.gitignore` (if exists)
+
+Also read the reference implementations:
+
+- `packages/devkit/tsconfig.lib.json`
+- `packages/devkit/package.json`
+- `packages/devkit/project.json`
+- `packages/devkit/.npmignore`
+
+Run `pnpm nx show target <name>:build-base` to see the inferred build target.
+Run `pnpm nx show target <name>:build` to see the full build target.
+
+### 2. Identify entry points
+
+Look at the package's root `.ts` files and any existing `exports` field. Common entry points:
+
+- `index.ts` (main)
+- `testing.ts`
+- `internal.ts`
+- `ngcli-adapter.ts`
+- Any other `.ts` files at the package root that re-export from `src/`
+
+Also check for `migrations.json` and `generators.json`/`executors.json` — these need exports entries too.
+
+### 3. Update `tsconfig.lib.json`
+
+Transform from the old pattern to the new pattern:
+
+**Before:**
+
+```json
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "../../dist/packages/<name>",
+    "tsBuildInfoFile": "../../dist/packages/<name>/tsconfig.tsbuildinfo"
+  }
+}
+```
+
+**After:**
+
+```json
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": ".",
+    "declarationDir": "dist",
+    "declarationMap": false,
+    "tsBuildInfoFile": "dist/tsconfig.tsbuildinfo",
+    "types": ["node"],
+    "composite": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "exclude": ["node_modules", "dist", ...existing excludes, ".eslintrc.json"],
+  "include": ["*.ts", "src/**/*.ts"]
+}
+```
+
+**Important**: Adjust `include` based on the package's actual structure. If the package has directories like `bin/`, `plugins/`, etc. at the root level (like `nx` does), include those too.
+
+### 4. Update `tsconfig.spec.json` (if exists)
+
+Change `outDir` from `../../dist/packages/<name>/spec` to `dist/spec`.
+
+### 5. Update `package.json`
+
+Key changes:
+
+- Add `"type": "commonjs"` near the top (after `private`)
+- Change `"main"` to `"./dist/index.js"`
+- Change `"types"` to `"./dist/index.d.ts"`
+- Add `"typesVersions"` for backwards compatibility with `moduleResolution: "node"` consumers
+- Add `"exports"` map with entries for each entry point
+
+Each export entry follows this pattern:
+
+```json
+"./entry-name": {
+  "@nx/nx-source": "./entry-name.ts",
+  "types": "./entry-name.d.ts",
+  "default": "./dist/entry-name.js"
+}
+```
+
+The main entry (`.`) uses `./index.ts`, `./index.d.ts`, `./dist/index.js`.
+
+Always include:
+
+```json
+"./package.json": "./package.json"
+```
+
+Include `"./migrations.json": "./migrations.json"` if the package has migrations.
+
+**Note**: The `@nx/nx-source` condition is a custom condition used for source-level resolution within the workspace (so other packages import from source, not dist).
+
+Add a `typesVersions` field for consumers using `moduleResolution: "node"` (which doesn't read `exports`):
+
+```json
+"typesVersions": {
+  "*": {
+    "testing": ["dist/testing.d.ts"],
+    "ngcli-adapter": ["dist/ngcli-adapter.d.ts"]
+  }
+}
+```
+
+Add an entry for each subpath export (excluding `.`, `./package.json`, and `./migrations.json`).
+
+### 6. Update `project.json`
+
+Add these sections:
+
+```json
+{
+  "release": {
+    "version": {
+      "generator": "@nx/js:release-version",
+      "preserveLocalDependencyProtocols": true,
+      "manifestRootsToUpdate": ["packages/{projectName}"]
+    }
+  },
+  "targets": {
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "packages/{projectName}"
+      }
+    }
+  }
+}
+```
+
+Do **not** override `build-base.outputs` in `project.json`. The `@nx/js/typescript` plugin reads `outDir` and `tsBuildInfoFile` from `tsconfig.lib.json` and infers the correct outputs (including the tsbuildinfo and the full set of file extensions). A hand-written override is almost always less complete than the inferred set.
+
+If the package already has a hand-written `build-base.outputs` array, **delete it** — don't try to patch it. An incomplete override that omits `dist/tsconfig.tsbuildinfo` causes a sandbox violation in _every consumer_ that has a TypeScript project reference to this package: their `tsc --build` reads the referenced project's `.tsbuildinfo`, but `dependentTasksOutputFiles` can only collect it if this package declares it as an output.
+
+Verify the inferred outputs include the tsbuildinfo:
+
+```bash
+pnpm nx show project <name> --json | jq '.targets["build-base"].outputs'
+# Must include "{projectRoot}/dist/tsconfig.tsbuildinfo"
+```
+
+Update the existing `build` target's `outputs` if they reference `{workspaceRoot}/dist/packages/<name>` — they should now reference `{projectRoot}/dist/`.
+
+Also update `dependsOn` in the `build` target: replace `"^build"` with `"^build"` if it isn't already, and make sure `"build-base"` is listed.
+
+### 7. Update eslint config
+
+Add `dist` to the ignores. For flat config (`eslint.config.mjs`):
+
+```js
+{ ignores: ['**/__fixtures__/**', 'dist'] },
+```
+
+For legacy `.eslintrc.json`:
+
+```json
+"ignorePatterns": ["!**/*", "node_modules", "dist"]
+```
+
+Do **not** add `*.d.ts` or `**/*.d.ts` — the base config already ignores `**/dist`, and `tsconfig.lib.json` (Step 4) sends all generated `.d.ts` files into `dist`, so they're already out of scope. Hand-authored `.d.ts` files in `src/` (e.g. `schema.d.ts`) generally don't need ignoring.
+
+### 8. Update `assets.json` (if exists)
+
+Change `outDir` from `"dist/packages/<name>"` to `"packages/<name>/dist"`.
+
+### 9. Add `files` field to `package.json`
+
+Instead of using `.npmignore`, add a `"files"` field to `package.json` (matching the `nx` package pattern). Remove `.npmignore` if it exists.
+
+```json
+"files": [
+  "dist",
+  "!dist/tsconfig.tsbuildinfo",
+  "migrations.json"
+]
+```
+
+Adjust based on the package's needs:
+
+- Add `"executors.json"` and/or `"generators.json"` if the package has them
+- Add any other non-TS files that need to be published
+- npm always includes `package.json` and `README.md` automatically — no need to list them
+
+### 10. Rename README.md and update build command
+
+If the package has a `README.md` at its root and uses the `copy-readme.js` script in its build target:
+
+1. Rename `README.md` to `readme-template.md` (`git mv`)
+2. Update the build command to pass explicit paths:
+   ```
+   node ./scripts/copy-readme.js <name> packages/<name>/readme-template.md packages/<name>/README.md
+   ```
+3. Update the build target `outputs` to `["{projectRoot}/README.md"]`
+
+The script's default behavior reads `packages/<name>/README.md` and writes to `dist/packages/<name>/README.md` — both wrong for the new layout. Passing explicit args fixes both.
+
+### 11. Update root `.gitignore`
+
+Under the section that lists generated README files (look for `packages/nx/README.md`), add:
+
+```
+packages/<name>/README.md
+```
+
+The generated README is written next to source (not into `dist/`), so it needs its own ignore.
+
+Do **not** add a `packages/<name>/**/*.d.ts` rule. The root `.gitignore` already has a top-level `dist` entry that ignores every `dist/` directory in the repo — and `tsconfig.lib.json` (Step 4) sets `declarationDir: "dist"`, so all generated `.d.ts` files land there. Adding a package-wide `**/*.d.ts` rule plus `!` re-includes for hand-authored `.d.ts` files (like committed `schema.d.ts` source files) is redundant defense-in-depth.
+
+### 12. Update docs generation paths
+
+Check `astro-docs/src/plugins/utils/` for any code that references `.d.ts` files from the package. The docs generation reads `.d.ts` entry points to build API reference pages. Paths that previously pointed to `dist/packages/<name>/foo.d.ts` (workspace root dist) or `packages/<name>/foo.d.ts` (package root) now need to point to `packages/<name>/dist/foo.d.ts`.
+
+For example, `devkit-generation.ts` had to be updated to look for `packages/devkit/dist/index.d.ts` instead of `packages/devkit/index.d.ts`.
+
+### 13. Update `scripts/nx-release.ts`
+
+Two things to do here:
+
+1. **Add the package to `packagesToReset`.** That array (around `scripts/nx-release.ts:76`) is the snapshot/restore list — every package whose source `package.json` gets mutated by `nx release` (because it now publishes from `packages/<name>/` directly, not `dist/packages/<name>/`) must be in this list. Otherwise the release will leave `packages/<name>/package.json` dirty in the working tree after running. **Easy to forget — and there is no test that catches it.**
+
+2. **Update any package-specific paths.** If the package has special release handling (like devkit's `hackFixForDevkitPeerDependencies`), update any paths from `./dist/packages/<name>/` to `./packages/<name>/`.
+
+### 14. Update imports across the workspace
+
+Search for imports from `@nx/<name>/src/` across all other packages. These internal imports need to be updated:
+
+- If the imported thing is re-exported through a public entry point (index.ts, internal.ts, etc.), update the import to use that entry point
+- If not, consider adding it to `internal.ts` or the appropriate entry point
+
+Use: `grep -r "from '@nx/<name>/src/" packages/ --include="*.ts" -l` to find affected files.
+
+Also check for imports in:
+
+- `e2e/` tests
+- `scripts/`
+- `tools/workspace-plugin/`
+- `astro-docs/`
+- `examples/`
+
+### 14b. (Optional) Lock down `./src/*` and route internal consumers through `./internal`
+
+When you ship the migration, the package's `exports` map exposes everything under `./src/*` if you keep the wildcard. That's a 100s-of-symbols-wide semi-private surface that pins the implementation layout forever — consumers (first-party and external) can reach into any source file. The cleaner long-term shape, matching `@nx/devkit`/`@nx/workspace`, is to drop the wildcard and route internal consumers through a single curated `./internal` entry. Skip this step if you'd rather defer (e.g. the package has very heavy internal usage and you'd prefer a smaller PR), but plan a follow-up.
+
+#### When to lock down vs defer
+
+- **Lock down in the same PR** if internal subpath imports number in the low hundreds AND the package isn't `workspace:*`-pinned by other not-yet-migrated packages whose dist code would crash at runtime against the older published version (see "Published-version mismatch" below).
+- **Defer to a follow-up PR** if the inventory is huge OR if dist-output code in other workspace packages depends on the OLD `./src/*` paths and those packages can't be migrated to local-dist yet. Lock down only once the immediate runtime-resolution surface is contained.
+
+#### Step-by-step
+
+**1. Inventory the subpath imports.** Scan for `from '@nx/<name>/src/...'`, plus runtime `require()`, dynamic `import()`, and `jest`/`vi.mock`-family calls:
+
+```bash
+grep -rEln "from ['\"]@nx/<name>/src/" --include="*.ts" --include="*.tsx" --include="*.js" --include="*.mjs" packages/ e2e/ scripts/
+grep -rEln "(require|jest\.mock|jest\.requireActual)\(['\"]@nx/<name>/src/" packages/ e2e/ scripts/
+```
+
+Compile a `subpath → set-of-imported-symbols` map. About 30 distinct subpaths and 60 symbols is typical for a package the size of `@nx/js`.
+
+**2. Identify runtime-string-resolved subpaths.** Some subpaths are referenced by _string default values_ the nx runtime resolves later (not static imports). The classic example: `packages/nx/src/command-line/release/config/config.ts` has `DEFAULT_VERSION_ACTIONS_PATH = '@nx/js/src/release/version-actions'`. These strings are also baked into pre-existing user `nx.json` files and you cannot rewrite them via a migration. **Keep those exact subpaths as explicit non-wildcard entries in the exports map** (not under `./internal`), and have the migration skip rewriting them.
+
+```bash
+# Search for string-default usages of the subpath in nx core
+grep -rEn "['\"]@nx/<name>/src/[^'\"]+['\"]" packages/nx/src/ --include="*.ts"
+```
+
+**3. Build `packages/<name>/internal.ts` at the package ROOT** (not inside `src/`, to mirror `@nx/devkit/internal`). Re-export every symbol callers reach for via `@nx/<name>/src/*`, BUT only symbols not already exported from `packages/<name>/src/index.ts`. Anything already public stays public — the migration sends those callers to `@nx/<name>`, not `@nx/<name>/internal`.
+
+To compute the public set:
+
+```bash
+grep -E "^export " packages/<name>/src/index.ts
+```
+
+…and recursively expand any `export *` lines. The "public-export reachability" calculation is fiddly enough that a small Python script with a recursive expand is worth it (see PR #35538 commit history for an example).
+
+Curate the new file:
+
+```ts
+// Semi-private surface for first-party Nx packages.
+//
+// External plugins should NOT import from here — this entry is curated for
+// internal consumers and may change without semver protection. Mirrors
+// `@nx/devkit/internal`.
+
+// Re-exports of nx-source internals (need `no-restricted-imports` overrides).
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+export { ... } from 'nx/src/plugins/.../something';
+
+export { walkTsconfigExtendsChain, type RawTsconfigJsonCache } from './src/utils/typescript/raw-tsconfig';
+// ... and so on, grouping by area.
+```
+
+Delete any pre-existing `packages/<name>/src/internal.ts` once its exports have been folded in.
+
+**4. Update `packages/<name>/package.json`.** Drop wildcards, add `./internal`, keep runtime-string subpaths as explicit entries:
+
+```jsonc
+{
+  "exports": {
+    ".": {
+      "@nx/nx-source": "./src/index.ts",
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js",
+    },
+    "./package.json": "./package.json",
+    "./migrations.json": "./migrations.json",
+    "./generators.json": "./generators.json",
+    "./executors.json": "./executors.json",
+    // Public side-channels (whatever you already had).
+    "./babel": {
+      "@nx/nx-source": "./babel.ts",
+      "types": "./dist/babel.d.ts",
+      "default": "./dist/babel.js",
+    },
+    // The new curated entry.
+    "./internal": {
+      "@nx/nx-source": "./internal.ts",
+      "types": "./dist/internal.d.ts",
+      "default": "./dist/internal.js",
+    },
+    // Runtime-string-resolved subpath kept for back-compat.
+    "./src/release/version-actions": {
+      "@nx/nx-source": "./src/release/version-actions.ts",
+      "types": "./dist/src/release/version-actions.d.ts",
+      "default": "./dist/src/release/version-actions.js",
+    },
+    // DROPPED: "./src/*", "./src/*.js", "./src/*/schema", "./src/*/schema.json"
+  },
+}
+```
+
+Also strip `src/*` glob entries from `typesVersions`. Replace with explicit non-wildcard entries that mirror the kept exports.
+
+**5. Codemod consumers in two passes.** Mechanical sed-style first, then a smarter split:
+
+```bash
+# Pass 1: every `from '@nx/<name>/src/...'` → `from '@nx/<name>/internal'`,
+# except the preserved subpaths from step 2.
+# (Use a Python/TS script — sed is fine for the simple cases too.)
+```
+
+```bash
+# Pass 2: split mixed imports. Any line like
+#   import { libraryGenerator, ensureTypescript } from '@nx/<name>/internal';
+# where `libraryGenerator` is publicly exported from `src/index.ts` becomes:
+#   import { libraryGenerator } from '@nx/<name>';
+#   import { ensureTypescript } from '@nx/<name>/internal';
+```
+
+Also handle these non-static cases:
+
+- `jest.mock('@nx/<name>/src/...', ...)` and `jest.requireActual(...)` — same rewrite. The whole mock surface is now `@nx/<name>/internal`, so `...jest.requireActual('@nx/<name>/internal')` spreads more than the original site mocked, but that's fine in practice.
+- Runtime `require('@nx/<name>/src/...')` — same rewrite.
+- Template-string fixtures inside `.spec.ts` files — careful! Don't let your codemod rewrite literal `from "@nx/<name>/internal"` substrings that _test_ the migration (it'll flip quote style and break the test). Either skip `*.spec.ts` files containing fixtures, or operate at AST level.
+
+**6. Collapse duplicate imports.** After the two-pass codemod, many files end up with two `import { ... } from '@nx/<name>/internal'` lines (or two `from '@nx/<name>'`). Run a third pass to merge same-source-same-`type`-prefix imports:
+
+```python
+# Match lines (anchored): `^import [type ]{ ... } from '@nx/<name>[/internal]';$`
+# Group by (is_type_only, source). For each group with >1 entry: keep the first
+# occurrence's position, merge the named bindings (dedupe), delete the others.
+# Don't merge across type/non-type — the semantics differ.
+```
+
+**7. Public-symbol audit.** After splitting, `internal.ts` must not re-export anything already exported from `src/index.ts`. If it does, namespace consumers (`import * as shared from '@nx/<name>/internal'`) will see only the curated set and `shared.publiclyExportedSymbol` becomes `undefined`. Cross-check:
+
+```bash
+# Symbols in internal.ts that are ALSO in the recursive index.ts export set
+# are a bug. Remove them from internal.ts. The codemod from step 5 should
+# have already routed their callers to `@nx/<name>`, but verify nothing is
+# left pointing at `@nx/<name>/internal` for these.
+```
+
+The three load-bearing patterns to verify:
+
+- `import * as shared from '@nx/<name>/internal'` followed by `shared.publicSymbol` — fix by changing source to `@nx/<name>`.
+- Runtime `const shared = require('@nx/<name>/internal')` followed by `shared.publicSymbol` — same fix.
+- Named imports of public symbols from `@nx/<name>/internal` — already split by step 5; verify nothing slipped through.
+
+**8. Ship a migration.** Add `packages/<name>/src/migrations/update-<version>/rewrite-<name>-internal-subpath-imports.ts` based on the workspace `move-typescript-compilation-import` template. It needs to handle:
+
+- Static `import [type] { ... } from '@nx/<name>/src/<anything>'`
+- `export [type] { ... } from '@nx/<name>/src/<anything>'`
+- Dynamic `import('@nx/<name>/src/<anything>')`
+- `require('@nx/<name>/src/<anything>')`
+- `jest.mock|unmock|doMock|dontMock|requireActual|requireMock|importActual|importMock(...)` and the `vi.` equivalents
+
+**Route by symbol, not blindly to `./internal`.** Some symbols reachable via `@nx/<name>/src/*` are _public_ — they're exported from `packages/<name>/src/index.ts` and ship on the main `@nx/<name>` entry. A migration that rewrites every `@nx/<name>/src/*` import to `@nx/<name>/internal` silently breaks any consumer importing a public symbol that way, because `internal.ts` deliberately does **not** re-export public symbols (step 7). Instead:
+
+- Hard-code the public symbol set (the recursively-expanded `export`s of `src/index.ts`) in the migration.
+- For a **named** `import`/`export` declaration, partition the named bindings: public symbols go to `@nx/<name>`, the rest to `@nx/<name>/internal`. Classify an `orig as alias` binding by `orig`. If both groups are non-empty, replace the single declaration with two — one per target — preserving any `import type` / `export type` modifier.
+- A **namespace** import (`import * as ns`), a **default** import, `export *`, every **call expression** (`require`, dynamic `import`, `jest.mock` family), and `typeof import('...')` **type queries** (`ImportTypeNode`) reference the module as a whole and can't be symbol-split — route them to `@nx/<name>/internal`.
+
+Skip the preserved subpaths from step 2 (e.g. `@nx/<name>/src/release/version-actions`). Use `ts.createSourceFile` for AST-based detection so you don't rewrite literals inside comments or template strings.
+
+**Don't forget `typeof import('...')`.** It parses as an `ImportTypeNode`, not a `CallExpression`, so it's a separate AST branch from the `require`/dynamic-`import` handling. Real-world consumers use the idiom `const m = require('@nx/<name>/src/x') as typeof import('@nx/<name>/src/x')` to get a typed runtime `require` — if the codemod only rewrites the runtime arg, the type arg stays pointing at the now-removed `./src/*` wildcard and the consumer fails to type-check. Handle it explicitly: walk `ImportTypeNode`s and rewrite `node.argument.literal` when the string starts with `@nx/<name>/src/`.
+
+Register in `packages/<name>/migrations.json` with `version: <current beta>`. The description should state the routing rule: named public-symbol imports/exports go to `@nx/<name>`, everything else to `@nx/<name>/internal`.
+
+Add a spec covering: public-symbol import (→ `@nx/<name>`), internal-symbol import (→ `@nx/<name>/internal`), mixed import split into two, aliased bindings classified by original name, type-only split, `export { ... } from` (public / internal / mixed), `export *`, namespace import, **default import**, single-quoted, double-quoted, deep subpath, `.js` extension, `require()`, dynamic `import()`, **`typeof import()` type queries (→ `/internal`)**, **a `<typeof import()>require()` cast in tandem** (catches the regression where the runtime arg gets rewritten but the type arg doesn't), the **full** jest mock family (`it.each` over `MOCK_HELPER_METHODS`), the **full** vi mock family, **`jest.mock('...', factory)` with a factory argument**, a non-mock `jest.*` call left alone, an import + `jest.mock` in the same file, preserved subpaths, non-`@nx/<name>` imports, unrelated string literals inside comments. Make sure every entry in `PUBLIC_SYMBOLS` and every entry in `MOCK_HELPER_METHODS` is exercised at least once — drift from hardcoded sets is the most likely silent regression.
+
+**9. Watch for the published-version-mismatch gotcha in example/test builds.**
+
+The workspace's root `node_modules/@nx/<name>` is the _published_ version (root `package.json` pins it to a real release tag, not `workspace:*`). When code at `dist/packages/<X>/...` does `require('@nx/<name>/internal')` at runtime, Node walks up from `dist/` and finds workspace-root `node_modules/@nx/<name>` — the published copy. If that version was released BEFORE this PR, it has no `internal.js` and resolution fails.
+
+Symptom:
+
+```
+Error: Cannot find module '@nx/<name>/internal'
+  requireStack: [
+    '/path/to/workspace/dist/packages/<X>/src/utils/foo.js',
+    ...
+  ]
+}
+```
+
+This bites specifically for examples or e2e flows that load `dist/packages/<other-package>/...` artifacts (e.g. an angular-rspack module-federation example that monkey-patches `Module._resolveFilename` to redirect `@nx/<other-package>` to dist). If the other-package's dist code does `require('@nx/<name>/internal')`, you'll hit this.
+
+Two fixes:
+
+- **(Preferred, if applicable.)** Migrate the _other_ package to local-dist too. Then its built code lives at `packages/<other>/dist/...`, walks up to `packages/<other>/node_modules/@nx/<name>` (a workspace symlink to source), and resolution finds the new `internal.js` because workspace source has it.
+- **(Band-aid for the in-between window.)** If migrating the other package is out of scope, extend the example's existing request-path patch to also redirect `@nx/<name>/internal` to the workspace source `packages/<name>/dist/internal`. Document it as a temporary measure tied to the same TODO that exists for the other-package redirect.
+
+Search aggressively for this pattern after step 8:
+
+```bash
+grep -rln "patchModuleFederationRequestPath\|Module._resolveFilename" examples/ e2e/ packages/
+```
+
+Any file that monkeypatches resolution is a candidate for needing the redirect.
+
+#### Validation
+
+After steps 1–9:
+
+```bash
+# Build the package (emits dist/internal.{js,d.ts})
+pnpm nx run <name>:build-base
+
+# Lint the package — @nx/dependency-checks may complain that the package
+# "uses itself" because of the dynamic self-reference in versions.ts. Add
+# `@nx/<name>` to `ignoredDependencies` in the dependency-checks rule config
+# (with a comment explaining: self-reference for require(join('@nx/<name>', 'package.json'))).
+pnpm nx run <name>:lint
+
+# Spec the migration
+pnpm nx test <name> -- --testPathPatterns=rewrite-<name>-internal-subpath-imports
+
+# Full affected — catches consumers, example monkey-patches, and any
+# missed split-mixed-imports.
+pnpm nx affected -t build,lint --base=<base-sha-before-migration>
+```
+
+If `nx affected` fails on a single example test with `Cannot find module '@nx/<name>/internal'`, that's step 9 — extend the example's request-path patch.
+
+If `nx affected` fails on a package with `TS2339: Property 'foo' does not exist on type 'typeof import(".../internal")'`, that's step 7 — a `shared.publicSymbol` call survived. Find it (`grep -rn 'shared\.<symbol>' packages/`) and rewrite the namespace source to `@nx/<name>`.
+
+### 15. Audit `require('../../package.json')` (or similar relative paths to the package.json)
+
+Search for `require\(['"]\.\..*package\.json` inside `packages/<name>/src/`. Any TS source file that reads the package's own `package.json` via a relative path is a **layout-fragility bug** that this migration triggers:
+
+- Before migration: source `packages/<name>/src/utils/versions.ts` → built `dist/packages/<name>/src/utils/versions.js`. `'../../package.json'` resolves to `dist/packages/<name>/package.json` (which the old build path copied there).
+- After migration: source unchanged → built `packages/<name>/dist/src/utils/versions.js`. `'../../package.json'` now resolves to `packages/<name>/dist/package.json` — **doesn't exist**. Every consumer that pulls in `nxVersion`/`NX_VERSION`/etc. crashes at module-load time with `Cannot find module '../../package.json'`. This breaks e2e tests broadly because most generators load `versions.ts`.
+
+**Fix**: replace the relative path with a **package-name self-reference**, using the dynamic `join()` form so eslint's `@nx/enforce-module-boundaries` doesn't trip on it:
+
+```ts
+// Before
+export const nxVersion = require('../../package.json').version;
+
+// After
+import { join } from 'path';
+export const nxVersion = require(join('@nx/<name>', 'package.json')).version;
+```
+
+A literal `require('@nx/<name>/package.json')` works at runtime but trips `enforce-module-boundaries`'s `noSelfCircularDependencies` check — the rule statically pattern-matches self-imports and fires before checking whether the import resolves to a non-main entry. The dynamic `join()` form is opaque to the static check, matches `@nx/devkit`'s established pattern, and resolves to the same path at runtime.
+
+Node resolves `@nx/<name>/package.json` via `node_modules` (workspace symlink in dev, real install in published), and the package.json's `exports` map already declares `./package.json` (you ensured this in Step 5). Works identically in source and dist contexts.
+
+Reference implementations:
+
+- `packages/nx/src/utils/versions.ts` — `require('nx/package.json').version` (works because `nx` is the project's own name; the static rule's entry-point check is lenient for the top-level `nx` package specifically)
+- `packages/devkit/src/utils/package-json.ts` — `NX_VERSION = require(join('nx', 'package.json')).version` (dynamic form)
+
+This was the source of the workspace-migration e2e regressions (PR #35643) and is one of the most-failure-prone steps to forget. Audit aggressively.
+
+### 15b. Audit `ensurePackage` + `await import(...)` pairs
+
+Search for `ensurePackage\(['"]@nx/` inside `packages/<name>/src/`. For every match, look at the next 5–20 lines for a `await import('@nx/<other>/...')` pulling from the same package. This pattern is **broken** under `nodenext`:
+
+- Before migration: `module: commonjs` made TypeScript downlevel `await import('@nx/<other>')` to `Promise.resolve(require('@nx/<other>'))`. The synchronous `require()` honors `Module._initPaths`, which is exactly where `ensurePackage` registers the on-demand temp install. Resolution succeeds.
+- After migration: `module: nodenext` preserves `import()` as a true ESM dynamic import. ESM resolution **ignores** `Module._initPaths` — it walks up `node_modules` from the importing file's location only. The temp install lives in a different temp dir, so the import fails with `Cannot find package '@nx/<other>'`.
+
+**Fix**: replace the dynamic import with a synchronous `require()`. The `ensurePackage` side effect makes it findable via `_initPaths`, and `require()` honors that:
+
+```ts
+// Before
+ensurePackage('@nx/eslint', nxVersion);
+const { foo, bar } = await import('@nx/eslint/internal');
+
+// After
+ensurePackage('@nx/eslint', nxVersion);
+// `require()` honors Module._initPaths (which ensurePackage updates); ESM
+// dynamic `import()` doesn't, so it can't see the temp install.
+const {
+  foo,
+  bar,
+}: typeof import('@nx/eslint/internal') = require('@nx/eslint/internal');
+```
+
+Collapse multiple successive `await import()`s of the same module into one `require()` destructuring while you're at it.
+
+This was the source of the M2 e2e regressions (Playwright/Web/React generators crashed at `Cannot find package '@nx/eslint'` from `ignore-vite-temp-files.js` and `ignore-vitest-temp-files.js`). One-line failure mode, but it can sit hidden in any code path that the unit-test suite doesn't exercise — only the published-then-installed flow exposes it. Audit every `ensurePackage` callsite.
+
+### 16. Preserve `add-extra-dependencies` if the package has one
+
+`scripts/add-dependency-to-build.js` is a release-time hack that injects an extra dep into the **published** `package.json` (e.g., it adds `nx` to `@nx/workspace`'s `dependencies`). It is **not dead code** — without it the transitive resolution chain breaks for downstream consumers.
+
+Concretely: created workspaces depend on `@nx/js`, which transitively depends on `@nx/workspace`. When the fork in `generate-preset.ts` runs `nx g @nx/workspace:preset`, Node's `require.resolve('@nx/workspace/package.json')` only finds the transitively-installed package because pnpm hoists `nx` along with `@nx/workspace` into `.pnpm/node_modules/` — and `nx` is hoisted there only because the **published** `@nx/workspace/package.json` declares it as a regular dependency. Drop that injection and the fork in the new workspace fails with `Unable to resolve @nx/workspace:preset` → `unable to find tsconfig.base.json`.
+
+When migrating a package that has the `add-extra-dependencies` target:
+
+1. **Keep** the target in `packages/<name>/project.json`.
+2. **Update** `scripts/add-dependency-to-build.js`: change the `pkgPath` from `../dist/packages/<package>/package.json` to `../packages/<package>/package.json` (the source manifest is now the published manifest under the local-dist layout).
+3. **Keep** the `pnpm nx run-many -t add-extra-dependencies --parallel 8` invocations in `scripts/nx-release.ts` (both the GitHub-release path and the local-publish path) — they fire between `runNxReleaseVersion` and `nx run nx:expand-deps`.
+4. Confirm the snapshot/reset list (`packagesToReset`) covers this package so the injection is undone after publish.
+
+If the package does not have the target, leave the script and the run-many calls alone — they no-op for any project without the target.
+
+### 17. Verify
+
+Run:
+
+```bash
+pnpm nx run-many -t test,build,lint -p <name>
+```
+
+Then:
+
+```bash
+pnpm nx affected -t build,test,lint
+```
+
+### Summary of the pattern
+
+The core idea is simple: instead of building to a shared `dist/packages/<name>/` at the workspace root, each package builds to its own `packages/<name>/dist/`. The `exports` map with `@nx/nx-source` condition lets workspace packages resolve to `.ts` source files during development, while external consumers get the built `.js` from `dist/`. This is like giving each package its own "output mailbox" instead of sharing one big mailbox.

.claude/skills/multi-version-compliance/SKILL.md

@@ -0,0 +1,399 @@
+---
+name: multi-version-compliance
+description: >
+  Apply or review multi-version support compliance for first-party Nx
+  plugins. Primary entry point: a Linear task ID (NXC-XXXX) from the
+  "Multi-version supported across plugins" milestone — the task carries the
+  resolved support window, findings, and "Needs human decision" items. Falls
+  back to self-discovery when no task exists. Use when asked to "fix
+  multi-version compliance for @nx/X", "do NXC-XXXX", "review this
+  compliance PR", or when working on a branch / PR titled "multi-version
+  support compliance for @nx/X". Covers the canonical shape
+  (assertSupportedPackageVersion, all-generators-enforce-floor.spec.ts,
+  peer dep alignment, requires-gate auditing, user-pin preservation,
+  executor / inferred-plugin feature gating).
+argument-hint: '[<NXC-XXXX> | @nx/<plugin> | review #<PR>]'
+allowed-tools: Bash, Read, Edit, Write, Glob, Grep, Agent, mcp__linear-server__get_issue, mcp__linear-server__list_comments, mcp__linear-server__get_milestone, mcp__linear-server__list_issues
+---
+
+# Multi-version compliance for Nx plugins
+
+## What this is
+
+The `nx migrate --first-party-only` flag lets users upgrade Nx without
+dragging the managed third-party ecosystems (Angular, Cypress, Playwright,
+Jest, Vitest, ESLint, etc.) along. For that to be safe, every first-party
+plugin must keep working across its declared support window — not silently
+fall through to the latest install constants on older workspaces, not
+silently break on newer ones.
+
+**Source-of-truth split:**
+
+| Source                                                                       | Owns                                                                                                                      |
+| ---------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Linear milestone "Multi-version supported across plugins" (project NXC-4072) | What's wrong per plugin, the resolved support window, open human decisions. Per-plugin tasks NXC-4381..NXC-4410 (P1–P29). |
+| This skill                                                                   | How to implement the canonical shape, code-level anti-patterns, gotchas, findings doc shape (no-task case).               |
+
+The skill is the gap-closer: it accepts a Linear task, parses it, drives
+the fix. When no task exists for the plugin, fix mode runs discovery in
+Phase 1–2 and produces a findings doc that mirrors a Linear task body —
+so the user can file it as a new task before proceeding.
+
+**Reference PRs (the canonical shape):**
+
+- `#35587` — `@nx/angular` — merged. Set the precedent. Introduced
+  `throwForUnsupportedVersion`.
+- `#35642` — `@nx/playwright` — merged. Generalized the shared helpers
+  into `@nx/devkit/internal`. Established executor / runtime feature-
+  gating.
+- `#35670` — `@nx/cypress` — merged. Added `excludeGenerators` to the
+  parameterized test helper.
+- `#35671` — `@nx/vitest` — open at time of writing. Demonstrates
+  "drop phantom peer-range claim" and "declared floor < effective floor"
+  patterns.
+
+Before citing any PR by number, verify state — these go stale:
+`gh pr view <N> --repo nrwl/nx --json state`. Verify any unmerged PR's
+contents via `gh pr diff <N> --repo nrwl/nx`.
+
+## Entry points
+
+| Invocation                                            | Mode              | Behavior                                                                                                                                                                                                                            |
+| ----------------------------------------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `multi-version-compliance <NXC-XXXX>`                 | Fix (primary)     | Fetch task, surface findings + decisions in Phase 2, wait for user OK before Phase 3 edits.                                                                                                                                         |
+| `multi-version-compliance` (no arg)                   | Ask for task ID   | Prompt for NXC-XXXX.                                                                                                                                                                                                                |
+| `multi-version-compliance @nx/<plugin>` (bare plugin) | Fix (task lookup) | Look up the per-plugin task in milestone NXC-4072. If found, confirm with user and enter fix mode. If not found, run discovery in Phase 1–2 (rubric against code), present findings, suggest filing as a new task before any edits. |
+| `multi-version-compliance review #<N>`                | Review            | Fetch PR, derive Linear task from branch name if possible, compare diff vs. task findings (or run pure code-level review if no task).                                                                                               |
+
+**Stop-after-Phase-2 (audit-equivalent):** if you want findings without
+edits, decline to approve at the end of Phase 2. The skill stops, no
+branch, no commits.
+
+**On a branch matching `nxc-NNNN` with no explicit arg:** before
+asking the user, suggest "Use NXC-NNNN?" inferred from the branch name.
+
+## Linear-fetching protocol
+
+Before any code-level work in Linear-driven mode, the skill MUST:
+
+1. **Check Linear MCP availability.** If `mcp__linear-server__get_issue`
+   isn't available (MCP server not installed / not connected), tell the
+   user and fall through to the no-task discovery path (fix mode Phase 1
+   step 2). Don't pretend to fetch.
+2. **Fetch the task.** `mcp__linear-server__get_issue id="NXC-XXXX"`.
+   If the call errors (invalid ID, network), halt and ask the user to
+   verify the ID.
+3. **Verify shape.** Confirm:
+   - Title matches `[multi-version][P##] \`@nx/<plugin>\` — multi-version support compliance`(per-plugin) or`[multi-version][W#] ...` (cross-cutting). If the pattern doesn't match, halt and ask the user to confirm this is the right task.
+   - Status. `Done` → ask whether re-audit or follow-up. `Canceled` → halt and ask.
+4. **Read description sections.** Every per-plugin task has:
+   - **Plugin:** — path, upstream support, peerDep declarations, per-major install map, paired secondaries.
+   - **Needs human decision** — open items blocking implementation.
+   - **Findings** — `(high|medium|low)` items with `[file:line]` and a suggested fix per item.
+   - **Verification checklist** — Sections A (Support window declarations) / B (Generator inputs) / C (Generator outputs) / D (Migrations) / E (Runtime) / F (Out-of-window UX).
+5. **Fetch comments.** `mcp__linear-server__list_comments issueId="..."`.
+   Audits attached as files / linked uploads may carry additional
+   context.
+6. **Surface "Needs human decision" as a batch.** Restate every decision
+   item in chat. The user can resolve all, defer some, or override.
+   Block until the user has acknowledged the set — don't proceed silently.
+7. **Translate findings → code changes.** Map each finding to a canonical
+   pattern in `references/canonical-shape.md`. The Linear task's
+   suggested fix is the authoritative scope; the skill verifies it
+   conforms to the canonical shape and flags any deviation.
+8. **Run the A–F checklist** against the final code state. The task's
+   checklist is the agreed scope. The skill verifies code-level
+   conformance.
+
+**Default to the task's resolved support window.** Don't re-derive it
+from code unless the user explicitly overrides. If the user overrides:
+restate the new window and confirm before applying.
+
+**Don't expand scope beyond the task's Findings without asking.** If you
+spot a new issue mid-fix: stop, present it, ask whether to (a) add it to
+this PR, (b) defer as a follow-up, or (c) update the Linear task as a
+comment.
+
+## Mode workflows
+
+### Fix mode (primary)
+
+**Phase 1 — Read.**
+
+1. If a Linear task ID was provided, fetch it per the Linear-fetching
+   protocol. If only a plugin name was provided, look up the per-plugin
+   task in milestone NXC-4072.
+2. **No task case.** If no task exists for this plugin: run discovery
+   instead — apply the policy ladder for the support window
+   (Rule 1: upstream LTS for Angular/React/ESLint/Next/Expo; Rule 2:
+   N & N-1; widen to existing supported set if larger), inventory the
+   plugin's code against the A–F rubric, find the effective floor by
+   walking imports, classify all results as new findings. The skill is
+   producing audit-quality output for a plugin that wasn't ticketed.
+3. If on a branch matching `nxc-NNNN`, read recent commits to understand
+   prior scope decisions.
+4. Read `references/canonical-shape.md` and `references/anti-patterns.md`.
+
+**Phase 2 — Align.**
+
+5. **(task case)** Surface every "Needs human decision" item from the
+   task as a batch. Wait for resolutions.
+6. **(task case)** Restate the Findings list with severity tags. Confirm
+   scope.
+7. **(no-task case)** Surface findings discovered from the rubric
+   inventory + decisions the rubric surfaces (floor raise/drop, peer
+   declarations, optional-vs-required peer, one-sided gates, etc.).
+   Suggest filing them as a new Linear task in milestone NXC-4072
+   before proceeding to Phase 3.
+8. **User OK gate.** Wait for explicit "proceed" before Phase 3.
+   Declining stops the skill — no branch, no edits. (This is the
+   audit-equivalent.)
+
+**Phase 3 — Implement** (per `canonical-shape.md`).
+
+9. Branch from `master` if needed using the repo's `nxc-NNNN` convention.
+10. Order: any shared-helper extension lands first; plugin changes land
+    after. Commit/PR titling defers to the user's conventions.
+11. For each Finding category, apply the canonical pattern:
+    - Section A → peer ranges + version map + install constants. Every
+      third-party package the plugin **invokes at runtime** (TS import,
+      executor spawning the CLI binary, or inferred-plugin emitting a
+      target with `command: '<bin>'`) gets a peer entry. Default to
+      `optional: true` via `peerDependenciesMeta` for gated surfaces
+      (executor opt-in, inferred plugin gated on config file presence).
+      Non-optional peers are reserved for packages every workspace using
+      the plugin needs.
+    - Section B → generator entry asserts, `keepExistingVersions`,
+      fresh-install branch.
+    - Section C → templates, schema stubs with runtime throws,
+      version-map coverage.
+    - Section D → `requires` gates per package per AND-semantics; split
+      mixed entries; retain intentional pre-floor entries. **Default to
+      bilateral bounds** (`>=N <M`) when writing a cross-major gate.
+      One-sided gates (`<N` with no lower, `>=N` with no upper) need a
+      justified reason (legacy cleanup, undefined source, v0→v1 bridge)
+      — record the reason in the findings doc or as a code comment.
+    - Section E → executor and inferred-plugin feature gates.
+    - Section F → below-floor throw via shared util.
+    - **Cross-cutting:** if the fix changes runtime behavior, update any
+      in-codebase docs (`astro-docs/`, `docs/`, inline `.md`) that
+      describe the changed behavior. Docs that contradict the code are a
+      correctness bug, not a PR-body concern.
+12. If during implementation you spot something not in the task's
+    Findings: stop, surface it, ask whether to (a) add to this PR, (b)
+    defer as a follow-up, or (c) update the Linear task as a comment.
+
+**Phase 4 — Tests** (same commit as Phase 3 usually).
+
+13. Add `all-generators-enforce-floor.spec.ts` — parameterized via
+    `assertGeneratorsEnforceVersionFloor`. This exercises every
+    generator's floor assert and is the high-value spec.
+14. Footgun: assert calls must be in place in every generator BEFORE
+    running the parameterized spec, or every untouched generator fails
+    and you'll restart.
+15. Optional: a per-plugin `assert-supported-<pkg>-version.spec.ts`
+    with the 5 canonical cases. The shared `assertSupportedPackageVersion`
+    already has full coverage in devkit, so this is mostly symmetry
+    across the PR series — skip unless the user asks.
+
+**Phase 5 — Verify locally.**
+
+16. `npx nx test <plugin> --testPathPattern="all-generators-enforce-floor"`
+    (add `assert-supported-` if you added the optional wrapper spec).
+17. `npx nx test <plugin> --testPathPattern="<modified-generator>"` per
+    touched generator.
+18. `npx nx format`.
+
+**Phase 6 — Hand off.** Code changes complete. The user drives
+commit/push/PR per their own conventions (loaded globally from
+`~/.claude/memory/workflow/git/`). This skill does not enforce PR title,
+body, commit shape, or related-issues format.
+
+### Review mode
+
+1. **Fetch PR.** `gh pr view <N> --repo nrwl/nx` and
+   `gh pr diff <N> --repo nrwl/nx`. For a local branch:
+   `git diff master...HEAD`.
+2. **Derive the Linear task.** Branch name `nxc-NNNN` → `NXC-NNNN`. If
+   no match: ask the user.
+3. **Fetch the task** (if derivable). Compare diff vs. task Findings:
+   every Finding addressed; nothing extra without justification. Flag
+   scope drift.
+   **If no task and the user has none:** skip task-comparison; run pure
+   code-level review against `canonical-shape.md` and `anti-patterns.md`.
+4. **Code-level checks.** Run the "Code-level verification (review-mode
+   lens)" section of `canonical-shape.md`. Cross-reference
+   `anti-patterns.md`. For each finding, anchor at `file:line` and cite
+   which reference PR / file demonstrates the correct pattern.
+   **Scope:** code, configs, migrations, and in-codebase docs that claim
+   runtime behavior. NOT PR title / body / commit shape — those defer to
+   the user's PR conventions.
+5. **Classify each finding.**
+   - **Only two inline categories:** `[blocker]` and `[non-blocker]`. No
+     "open question," "ask," or other inline tags. Questions for the
+     author surface in the closing "Open questions for author" block,
+     drawn from non-blocker findings — list each question once.
+   - **Severity is independent of scope-drift.** A finding can be both a
+     blocker AND not in the Linear task. Flag it as a blocker in the
+     code-level section AND list it under "in PR but not in Linear task"
+     in scope drift. Don't hedge with "in this PR or follow-up?" — if
+     it's a blocker, the answer is "this PR."
+   - **Group related non-blockers.** When multiple non-blockers describe
+     symptoms of one blocker (e.g., five symptoms of a single
+     `version-utils.ts` duplication), list them as sub-bullets under
+     the blocker with "(resolved when §X is fixed)" rather than as N
+     separate top-level non-blockers.
+   - **Be terse on passes.** A section with no findings gets a single
+     summary line ("Pass — all 7 generator entries assert at first
+     statement"), not a per-file enumeration. Detail is reserved for
+     blockers and non-blockers. The reviewer's audience skims for
+     actionable items; passing checks should not eat reading budget.
+6. **Output.** Markdown checklist of blockers / non-blockers anchored at
+   `file:line`, followed by the structured verdict block from
+   `canonical-shape.md` §"Verdict template". The verdict block is the
+   skimmable index — produce it, don't substitute a free-form prose
+   summary. Do not post via `gh pr review` unless the user explicitly
+   asks.
+
+## Which references to load (context hygiene)
+
+| Mode                         | Required                                                                                    | Optional                                                                                                        |
+| ---------------------------- | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
+| Fix                          | `canonical-shape.md`, `anti-patterns.md`                                                    | `gotchas.md` (effective floor, ecosystem lockstep, cypress inline tree), `examples.md` (when copying a pattern) |
+| Review                       | `anti-patterns.md`, `canonical-shape.md` (especially the "Code-level verification" section) | `gotchas.md` (cross-plugin coordination, lockstep), `examples.md` (when citing)                                 |
+| "What is compliance?" answer | none                                                                                        | answer from SKILL.md alone                                                                                      |
+
+References are ~100–500 lines each. Don't pull all of them just because
+you're invoked. Match the load to the mode.
+
+## Critical rules (apply in every mode)
+
+1. **Linear task is the source of truth for scope** (ratified decisions
+   and Findings).
+   - (a) Don't produce a parallel scope document. The task IS the scope.
+     Fix mode runs against the task as input — drift checks, new
+     findings, and decisions feed back to the task (via comments or as
+     deferred items), not into a competing source of truth.
+   - (b) Don't expand a fix beyond the task's Findings without
+     surfacing the new issue.
+   - (c) Don't second-guess the task's resolved support window without
+     an explicit user override.
+2. **Do not create or duplicate shared helpers.** They live in
+   `@nx/devkit/internal` (`assertSupportedPackageVersion`,
+   `getInstalledPackageVersion`, `getDeclaredPackageVersion`,
+   `throwForUnsupportedVersion`, `normalizeSemver`, `isNonSemverDistTag`)
+   and `@nx/devkit/internal-testing-utils`
+   (`assertGeneratorsEnforceVersionFloor`). Reject any local
+   re-implementation (`cleanVersion`, `getInstalled<Pkg>VersionRuntime`,
+   private `throwBelowFloor`, etc.). See `canonical-shape.md`.
+3. **Above-ceiling is silent fallthrough.** Do not warn, do not throw,
+   do not branch. Reject `throwAboveWindow`, `warnAboveCeiling`,
+   `versions()` with `switch + throw default:`. The only throw is below
+   the declared floor.
+4. **`keepExistingVersions: true` is for generators only.** Migration
+   generators (`src/migrations/`) are exempt — their job is to bump.
+   Do not flag missing flags in migration code.
+5. **Floor assert is the first statement in the function doing the
+   actual work.** Wrapper/internal split (cypress, playwright): in
+   `*Internal`. Single-function generators (angular): in the function
+   itself. Not conditional, not inside an install branch, not after a
+   tree read.
+6. **Phase 1–2 never writes, never branches.** Discovery, finding
+   classification, and decision-surfacing happen on the current branch
+   with no edits. Any working artifact (e.g., a findings doc for a
+   no-task case, multi-plugin scratch notes) goes in `tmp/` (gitignored)
+   and stays uncommitted. No `TRIAGE-REPORT.md` / `AUDIT.md` at repo
+   root. Branch creation and edits start at Phase 3, after the user OK.
+7. **PR / commit conventions are out of scope.** Title format, body shape,
+   commit-message structure, related-issues handling, push flags, etc.
+   are governed by the user's global memory (`pr-creation-shorthand.md`,
+   `push-conventions.md`, `explain-before-committing.md`,
+   `chore-not-fix-non-prod.md`). Don't enforce or flag these from this
+   skill — defer to whatever the user's conventions resolve to at PR time.
+
+## Findings doc template (Phase 2 output, used when no Linear task exists)
+
+When fix mode hits the no-task case (Phase 1 step 2), produce
+`tmp/<plugin>-findings.md` shaped to mirror a Linear task body so the
+user can file it as a new task in milestone NXC-4072 before proceeding
+to Phase 3.
+
+For plugins managing multiple primary packages, repeat the install-map
+/ decisions / findings bullets per primary.
+
+```md
+# @nx/<plugin> — multi-version support compliance findings
+
+> No Linear task in milestone NXC-4072. This doc is filing-ready —
+> create the task with this body before proceeding to fix.
+
+## Plugin
+
+- Path: packages/<plugin>
+- Upstream support: <official policy if any, else "no formal LTS">
+- peerDep declarations: <list>
+- Per-major install (`<file>` branches on installed `<package>` major):
+  - v<N-1>: <constants>
+  - v<N>: <constants> (default)
+- Paired secondaries: <list of ecosystem-locked siblings>
+
+## Needs human decision
+
+1. <decision 1 — e.g., raise floor to vN.0.0 vs keep current>
+2. <decision 2 — e.g., drop ^1.0.0 from peer (no v1 install lane)>
+
+## Findings
+
+- **(high) <one-line summary>** [file:line]
+  _Suggested fix_: <one-line>
+- **(medium) ...**
+- **(low) ...**
+
+## Verification checklist (A–F)
+
+### A. Support window declarations
+
+- [ ] peerDep ranges match the support window
+- [ ] Version map / runtime branching covers every supported major
+- [ ] Every third-party package the plugin **invokes at runtime** has a peerDep entry. "Invokes" = TS import/`require` OR executor spawns its CLI binary OR inferred plugin emits a target whose `command` invokes its CLI (look for `externalDependencies: ['<pkg>']` in emitted target inputs). Packages the generator installs for the user to consume independently (ESLint plugins loaded by the user's eslintrc, `@types/*`) don't need peer-declaration.
+- [ ] Peers needed only when a user opts into a specific surface (executor opt-in, inferred plugin gated on config file presence, opt-in preset) are declared **optional** via `peerDependenciesMeta: { "<pkg>": { "optional": true } }`. Required-non-optional peers are reserved for packages every workspace using the plugin needs.
+
+### B. Generator inputs
+
+- [ ] Generators don't overwrite installed third-party versions
+  - [ ] `addDependenciesToPackageJson` passes `keepExistingVersions=true` or branches on detected version
+- [ ] Fresh-install path installs the latest supported version
+
+### C. Generator outputs
+
+- [ ] Templates compile and run on every supported version
+- [ ] Generated `project.json` target shape valid on every major
+- [ ] Default option values valid on every major
+- [ ] Version map covers every managed third-party dep — no gaps
+- [ ] Schema accepts union of options; runtime throws when inapplicable
+
+### D. Migrations (migrations.json + packageJsonUpdates)
+
+- [ ] Cross-major `packageJsonUpdates` declare `requires` per bumped package
+- [ ] `requires` ranges are bilateral (`>=N <M`) by default. One-sided ranges (`<N` with no lower, `>=N` with no upper) are intentional (legacy cleanup, undefined source major, v0→v1 bridge) — flagged in "Needs human decision" or noted in the Findings.
+- [ ] Every migration declares `requires` against the touched package
+- [ ] Nx-only migrations have no third-party `requires`
+- [ ] No silent gap in `packageJsonUpdates` across the support window
+
+### E. Runtime
+
+- [ ] Executors branch on installed version where behavior diverges
+- [ ] Inferred plugin (createNodes/V2) parses configs across every major
+
+### F. Out-of-window UX
+
+- [ ] Below-floor: throws via shared util naming package + installed + floor; no silent fall-through
+
+## Out-of-scope (deferred follow-ups)
+
+- <e.g., consolidate ... across plugins — separate PR>
+```
+
+## References
+
+See "Which references to load" near the top. Don't pull all of them.

.claude/skills/multi-version-compliance/references/anti-patterns.md

@@ -0,0 +1,329 @@
+# Anti-patterns
+
+Patterns to reject in your own work and flag in reviews. Each entry: what it looks like, why it's wrong, what to do instead, and a reference.
+
+## 1. Local re-implementation of the shared helpers
+
+**Looks like:** A new file in the plugin defining any of:
+
+- `throwBelowFloor` / `throwAboveWindow` / `assertVersion` / `checkMinimumVersion` — duplicates `throwForUnsupportedVersion` / `assertSupportedPackageVersion`.
+- `function cleanVersion(v) { return clean(v) ?? coerce(v)?.version ?? undefined; }` — duplicates `normalizeSemver`.
+- `getInstalledRsbuildVersionRuntime` / `getInstalled<X>FromFs` reading `require('<pkg>/package.json')` directly — duplicates `getInstalledPackageVersion`.
+- Inline `clean(declared) ?? coerce(declared)` chain at a generator entry point — duplicates `getDeclaredPackageVersion`.
+- Open-coded tree-branch in `getInstalled<Pkg>Version(tree?)`: `getDependencyVersionFromPackageJson(tree, pkg)` + an `installedVersion === 'latest' || installedVersion === 'next'` check + a `clean(...) ?? coerce(...)?.version ?? null` chain. The dist-tag list and the normalization chain are both centralized in `getDeclaredPackageVersion` (via `NON_SEMVER_DIST_TAGS` / `normalizeSemver`). A local copy silently misses new entries if `NON_SEMVER_DIST_TAGS` grows.
+
+**Why wrong:** The shared helpers in `@nx/devkit/internal` and `@nx/devkit/internal-testing-utils` already exist. Duplicates create drift — one will get the `latest`/`next` handling, the other won't; one will use `getNxRequirePaths()` for pnpm-strict resolution, the other won't.
+
+**Do instead:** Call `assertSupportedPackageVersion(tree, pkg, floor)` via the per-plugin wrapper (`assertSupportedXVersion`). For executor-side reads: `getInstalledPackageVersion(pkg)`. For tree-side normalization: `getDeclaredPackageVersion(tree, pkg, latestKnown)`. For raw semver cleaning: `normalizeSemver(v)`.
+
+For the `getInstalled<Pkg>Version(tree?)` wrapper specifically:
+
+```ts
+export function getInstalledCypressVersion(tree?: Tree): string | null {
+  if (!tree) {
+    return getInstalledPackageVersion('cypress');
+  }
+  return getDeclaredPackageVersion(tree, 'cypress');
+}
+```
+
+**Omit the third arg by default.** It conflates "missing" with "dist tag" — both fall back to the supplied fresh-install constant. That's almost never what the caller wants; consumers that need a `?? latest` fallback should encode it at the call site, not globally in the helper (rspack/rsbuild precedent). See `canonical-shape.md` §"Dist-tag semantics — third arg".
+
+**Reference:** Compliant — `packages/cypress/src/utils/assert-supported-cypress-version.ts` (7 lines); `packages/cypress/src/utils/versions.ts` `getInstalledCypressVersion` (no third arg); `packages/rspack/src/utils/version-utils.ts` and `packages/rsbuild/src/utils/version-utils.ts` (same shape). Concrete anti-pattern — PR `#35676` introduces `function cleanVersion` (`packages/rsbuild/src/utils/versions.ts`) and `getInstalledRsbuildVersionRuntime` reading `require('@rsbuild/core/package.json')`. Both should call the shared helpers instead.
+
+## 2. Above-ceiling throw or warn
+
+**Looks like:** `if (major > maxKnown) throw …`, `if (major > maxKnown) logger.warn …`, `versions()` with a `switch + throw default:`, any `warnAboveCeiling` / `throwAboveWindow` helper.
+
+**Why wrong:** Explicit policy. Above-ceiling falls through silently to `latestVersions`. Throwing breaks users on newer versions of third-party packages, which is the opposite of the initiative's intent. The angular reference implementation does not warn or branch above the highest known major, and every subsequent plugin compliance PR follows that convention.
+
+**Do instead:** `versionMap[major] ?? latestVersions`. Below-floor is caught by the generator-level assert; the `versions()` function is just a lookup.
+
+**Reference:** Compliant — `packages/cypress/src/utils/versions.ts` after `#35670` rewrite. Anti-pattern (before fix) — same file before `#35670` had `switch + throw default:`.
+
+## 3. Hardcoded third-party version in generator body
+
+**Looks like:**
+
+```ts
+addDependenciesToPackageJson(tree, {}, { rspack: '^1.1.10' });
+```
+
+in a generator.
+
+**Why wrong:** Bypasses the `versions(tree)` routing and the install-lane logic. New majors will not be picked up; older workspaces get the wrong version.
+
+**Do instead:** Route through `versions(tree)` and reference the per-major entry. If you genuinely have a version that's the same across all majors, still put it in the map for consistency.
+
+## 4. Init generator overwriting pinned versions
+
+**Looks like:** `addDependenciesToPackageJson(tree, …, …, undefined, options.keepExistingVersions)` where the schema default is `false`. Or no fifth argument at all (defaults to `false`).
+
+**Known-incomplete reference:** `@nx/angular`'s `init/schema.json` currently has `default: false` and `init.ts` passes `options.keepExistingVersions` directly — PR `#35587` did not fix this. The angular init generator therefore still has this bug. Flagging it in a non-angular compliance PR is correct; fixing it in passing during another angular PR is also appropriate.
+
+**Why wrong:** Generators bump packages = the user's pinned version is silently overwritten on re-run. Bumping is the job of migrations, not generators.
+
+**Do instead:** Pass `keepExistingVersions: true` (positional 5th arg) or `options.keepExistingVersions ?? true`. Flip the schema default to `true`.
+
+**Reference:** Compliant — `packages/cypress/src/generators/init/init.ts` and `init/schema.json` after `#35670`. Anti-pattern — the same files before `#35670` had schema default `false`.
+
+## 5. `requires` gate on an Nx-only migration
+
+**Looks like:**
+
+```json
+{
+  "update-unit-test-runner-option": {
+    "requires": { "@angular/core": ">=21.0.0" },
+    "description": "Update 'vitest' unit test runner option to 'vitest-analog' in generator defaults."
+  }
+}
+```
+
+when the migration only writes to `nx.json`.
+
+**Why wrong:** The migration applies regardless of third-party version — it's rewriting an Nx-owned generator default. The gate causes pre-v21 workspaces with the stale default to silently skip the migration and stay broken.
+
+**Do instead:** Remove the `requires` entry entirely. Nx-only migrations have no third-party gate.
+
+**Reference:** Anti-pattern (before fix) — `packages/angular/migrations.json` `update-unit-test-runner-option`. Fix — `#35587` removed the gate.
+
+## 6. Cross-major `packageJsonUpdates` with no `requires`
+
+**Looks like:**
+
+```json
+{
+  "21.3.0": {
+    "packages": {
+      "jest": { "version": "^30.0.0" }
+    }
+  }
+}
+```
+
+with no `requires` gate, when this is a v29 → v30 bump.
+
+**Why wrong:** The bump fires for every workspace — including workspaces already on v30 (idempotent best case) or workspaces on v28 or below (which would silently land on v30 without going through any v29 → v30 codemods). Source-major gate ensures the bump only fires for workspaces actually in the source range.
+
+**Do instead:**
+
+```json
+{
+  "21.3.0": {
+    "requires": { "jest": ">=29.0.0 <30.0.0" },
+    "packages": { "jest": { "version": "^30.0.0" } }
+  }
+}
+```
+
+**Reference:** Compliant — `packages/angular/migrations.json` MF entries after `#35587`. Anti-pattern examples on master at time of writing — `@nx/jest` `21.3.0`, `@nx/eslint` `20.7.0`, `@nx/vite` `20.5.0` (verify by inspecting each plugin's `migrations.json` for cross-major `packageJsonUpdates` entries lacking `requires`).
+
+## 7. Gating ecosystem-locked siblings on the primary's major alone
+
+**Looks like:** A migration that bumps `@ngrx/store` from v18 to v19 with `requires: { "@angular/core": ">=19.0.0" }` only — no `@ngrx/store` entry.
+
+**Why wrong:** `@ngrx/store` is independent of `@angular/core` versioning. A workspace can be on `@angular/core: 19` without having `@ngrx/store: 18` (might not use ngrx at all, or might be on v17). Gating on `@angular/core` fires the migration in workspaces where it has nothing to do.
+
+**Do instead:** Add the sibling to `requires`: `{ "@angular/core": ">=19.0.0", "@ngrx/store": ">=18.0.0 <19.0.0" }`. For Angular ecosystem siblings: `@angular/cli`, `@angular/ssr`, `@angular-devkit/build-angular` (v20+) are peer-locked via `@angular/core` and don't need their own gate. `@ngrx/*`, `@angular-eslint/*`, `zone.js`, `jest-preset-angular` are independent and do.
+
+**How to verify pairing:** read the sibling package's `peerDependencies` at the version range being bumped from. If it pins the primary's major, the primary's `requires` covers it. If it doesn't, the sibling is independent and needs its own gate.
+
+## 8. Peer dep claiming a major with no install branch (phantom claim)
+
+**Looks like:**
+
+```json
+{
+  "peerDependencies": {
+    "vitest": "^1.0.0 || ^2.0.0 || ^3.0.0 || ^4.0.0"
+  }
+}
+```
+
+when `versions.ts` has no v1 entry and no `isVitestV1` branch anywhere.
+
+**Why wrong:** The plugin advertises support for a version it doesn't honor. v1 workspaces silently fall through to v4 install constants.
+
+**Do instead:** Drop the unsupported major from the peer. `vitest: "^2.0.0 || ^3.0.0 || ^4.0.0"`. If the support is desired, add the install lane.
+
+**Reference:** Pattern demonstrated in open PR `#35671` (`@nx/vitest`) — drops `^1.0.0` from the `vitest` peer because there's no v1 install lane in the plugin's `versions.ts`. Inspect via `gh pr diff 35671 --repo nrwl/nx -- packages/vitest/package.json`. Verify state first.
+
+**Related — drop EOL major (different reasoning, same action):** the major HAS an install lane but is EOL upstream (e.g., Storybook's official policy is "top 3 majors only"; v7 is EOL). Drop it from the peer because it's upstream-unsupported, not because the plugin doesn't honor it. Concrete example: NXC-4406 calls out dropping Storybook v7 from `@nx/storybook`'s peer per Storybook's top-3-majors policy.
+
+## 8a. PeerDep range wider than the runtime dep pin
+
+**Looks like:**
+
+```json
+{
+  "peerDependencies": {
+    "@typescript-eslint/parser": "^6.0.0 || ^7.0.0 || ^8.0.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/parser": "^8.0.0"
+  }
+}
+```
+
+The plugin's own runtime dep pins ^8, but the peer claims ^6/^7/^8.
+
+**Why wrong:** Distinct from §8 — here the install lane exists (in `dependencies`), but the lane only ships one major. The peer is over-promising relative to what the plugin actually runs against. A workspace on ^6 will satisfy the peer but won't get a compatible runtime once `@typescript-eslint/parser@^8` resolves.
+
+**Do instead:** Tighten the peer to the actually-supported runtime range, or widen the runtime dep + add the install/branch lanes for the additional majors.
+
+**Reference:** NXC-4388 (`@nx/eslint-plugin`).
+
+## 9. Top-level `require()` of an optional peer in an executor
+
+**Looks like:**
+
+```ts
+// at the top of executor.impl.ts
+const cypress = require('cypress');
+```
+
+**Why wrong:** When cypress is absent (not yet installed, peer mismatch, etc.), the executor throws `MODULE_NOT_FOUND` at module load time, before any user-friendly error. Especially bad for deprecated executors that should fail with a deprecation message.
+
+**Do instead:** `require` inside the function body, after the version detection / clear error.
+
+## 10. Anything-but-`requires` as substitute for `requires`
+
+**Looks like (variant A — `incompatibleWith` standing in):**
+
+```json
+{
+  "21.0.0-source-bump": {
+    "incompatibleWith": { "@angular-devkit/build-angular": "<21.0.0" },
+    "packages": { "...": { "version": "..." } }
+  }
+}
+```
+
+to "gate" a bump to v21+ source workspaces.
+
+**Looks like (variant B — runtime per-package guard):**
+
+```ts
+// inside the migration function body
+const installed = getInstalledVersion('@typescript-eslint/parser');
+if (gte(installed, '8.0.0') && lt(installed, '8.13.0')) {
+  // run the migration
+}
+return; // otherwise skip
+```
+
+with no `requires` block on the migration entry in `migrations.json`.
+
+**Why wrong:** Neither approach is a source-major gate.
+
+- `incompatibleWith` blocks running on workspaces that have the matching version — it doesn't gate to a source-major range. A workspace on `@angular-devkit/build-angular: 22.0.0` will still pass the `incompatibleWith` check.
+- A runtime per-package guard runs the migration _body_ on every workspace and skips internally. The migration record still appears as "executed" to the migrate runner, and any side effects (logging, partial work) leak. The `nx migrate` runner uses `requires` as the source-major filter; bypassing it means the migration isn't filtered at the right layer.
+
+**Do instead:** `requires: { "<pkg>": ">=N.0.0 <(N+1).0.0" }` — the actual source-major gate at the migration-entry level. Drop the in-body guard once the `requires` is in place.
+
+**Reference:** Anti-pattern (variant B) — `@nx/eslint` `update-typescript-eslint-v8.13.0` (NXC-4387) has runtime `gte('8.0.0') + lt('8.13.0')` per-package guards but no `requires` block. `@nx/jest` similar with `incompatibleWith` (NXC-4391).
+
+## 11. Naming a specific plugin in shared helper docstrings
+
+**Looks like:** A JSDoc in `assert-generators-enforce-version-floor.ts` referencing `migrate-to-cypress-11` as the example use case for `excludeGenerators`.
+
+**Why wrong:** The helper is shared across plugins. Naming one plugin in its docstring is leaky.
+
+**Do instead:** Generic phrasing — "generators that must run below the floor by design (e.g., migrators that lift sub-floor workspaces onto a supported version)".
+
+**Reference:** an early draft of `#35670`'s test helper had the plugin-specific JSDoc; the merged version uses generic phrasing.
+
+## 12. Both schema `"default": true` AND `options.keepExistingVersions ?? true`
+
+**Looks like:**
+
+```json
+{ "keepExistingVersions": { "default": true } }
+```
+
+combined with
+
+```ts
+addDependenciesToPackageJson(tree, …, …, undefined, options.keepExistingVersions ?? true);
+```
+
+**Why wrong:** Two sources of truth. Either the schema default does the job (and `options.keepExistingVersions` will always be `true`) or the `?? true` fallback handles it (and the schema default is redundant).
+
+**Do instead:** Pick one. Schema default is sufficient when the call site uses `options.keepExistingVersions` directly. The `?? true` fallback is only needed if the schema can be bypassed (programmatic invocation without schema validation).
+
+## 13. Manual `RegExp` matching in tests instead of substring `toThrow`
+
+**Looks like:**
+
+```ts
+.rejects.toThrow(new RegExp(`Unsupported version of \\\`${packageName}\\\` detected`));
+```
+
+**Why wrong:** Escape bugs. The backtick and the `${}` are easy to get wrong. The shared helper uses substring matching for a reason.
+
+**Do instead:**
+
+```ts
+.rejects.toThrow(`Unsupported version of \`${packageName}\` detected`);
+```
+
+**Reference:** see how `assertGeneratorsEnforceVersionFloor` itself does the match in `packages/nx/src/internal-testing-utils/assert-generators-enforce-version-floor.ts` (grep for `Unsupported version of`).
+
+## 14. Validating only at install sites instead of generator entry
+
+**Looks like:** A `if (installedVersion < floor) throw …` check guarding only the `addDependenciesToPackageJson` call inside a generator, while the rest of the generator runs unconditionally.
+
+**Why wrong:** The generator may write configuration or templates incompatible with the sub-floor third-party version before reaching the install branch. The assert must be at the entry point so nothing else runs.
+
+**Do instead:** `assertSupportedXVersion(tree)` as the first statement in the generator's working function (`*Internal` for plugins with the wrapper/internal split; the function itself for single-function generators). The install branch can then assume the floor is met.
+
+## 15. Per-major version aliases alongside the bundle map
+
+**Looks like:**
+
+```ts
+export const vitestV4Version = '~4.1.0';
+export const vitestV3Version = '^3.0.0';
+export const vitestV2Version = '^2.1.8';
+export const vitestVersion = vitestV4Version;
+
+export const vitestV4CoverageV8Version = '~4.1.0';
+export const vitestV3CoverageV8Version = '^3.0.5';
+// ...etc
+
+const versionMap = {
+  3: { vitestVersion: '^3.0.0', vitestCoverageV8Version: '^3.0.5' },
+  4: { vitestVersion: '~4.1.0', vitestCoverageV8Version: '~4.1.0' },
+};
+```
+
+**Why wrong:** The aliases (`vitestV3Version`, `vitestV3CoverageV8Version`, etc.) duplicate the `versionMap` entries. They drift over time — someone bumps the map but forgets the alias (or vice versa), and the plugin starts installing one version via generators and another via tests/runtime. Also: every dropped major (e.g., when raising the floor) becomes three or four delete lines instead of one map entry.
+
+**Do instead:** Keep the bundle pattern — the per-major `versionMap` is the only place those values live. Stable (cross-version-identical) deps stay as top-level `export const`s; varying deps are accessed via `versions(tree).<key>` or directly from the top-level `latestVersions` bundle.
+
+**Reference:** Open PR `#35671` initially carried `vitestV2Version` / `vitestV3Version` / `vitestV4Version` aliases. A follow-up commit (`chore(testing): adopt cypress version-resolution pattern in @nx/vitest`) dropped them in favor of the bundle pattern. Inspect via `gh pr view 35671 --repo nrwl/nx --json commits`.
+
+## 16. Declared floor below the effective floor
+
+**Looks like:** `peerDependencies` lists `"vitest": "^2.0.0 || ^3.0.0 || ^4.0.0"` and `versions.ts` has a `versionMap` entry for `2`, but somewhere in the plugin's executor / runtime / plugin code there's an import of a third-party API that only exists in v3+:
+
+```ts
+// In a runtime helper used by the executor:
+import { getRelevantTestSpecifications } from 'vitest/node';
+// ^ This API only exists in vitest >= 3.0.0.
+```
+
+**Why wrong:** A workspace on v2 will pass the floor assert (peer + versionMap claim support), then crash at runtime with `getRelevantTestSpecifications is not a function`. The peer is lying.
+
+**Do instead:** Raise the floor to the lowest major where every called third-party API exists. Drop the now-unsupported entries from `versionMap`, `peerDependencies`, and the per-major version aliases (if any). The `assert-supported-<pkg>-version.spec.ts` sub-floor test now covers the dropped major.
+
+**Reference:** Open PR `#35671`'s second commit (`fix(testing): drop vitest v2 support from @nx/vitest`) — originally proposed a v2 floor matching the lowest install lane, then raised to v3 after audit caught the `getRelevantTestSpecifications` usage. Inspect via `gh pr view 35671 --repo nrwl/nx --json commits`.
+
+## 17. Creating a branch during Phase 1–2 (discovery / read-only)
+
+**Looks like:** `git checkout -b <some-branch>` before the user has approved Phase 3 edits.
+
+**Why wrong:** Phase 1–2 produces findings, not commits. Creating a branch creates pressure to commit something. Any working artifact (e.g., `tmp/<plugin>-findings.md` for the no-task case) goes in `tmp/` (gitignored) — for the user to read and scope from, not to commit.
+
+**Do instead:** Run Phase 1–2 on the current branch (typically `master`). Output to `tmp/<plugin>-findings.md` if you wrote one. Branch creation belongs in Phase 3, after explicit user approval to proceed with edits.

.claude/skills/multi-version-compliance/references/canonical-shape.md

@@ -0,0 +1,655 @@
+# Canonical shape
+
+What a compliant plugin looks like. Don't deviate without a documented reason.
+
+The first half of this file ("How to write") describes the canonical structure
+you produce in fix mode. The tail section ("Code-level verification") is the
+review-mode lens — markers to look for in a diff.
+
+## Shared helpers (already merged — use, don't duplicate)
+
+### `@nx/devkit/internal`
+
+Source: `packages/devkit/src/utils/version-floor.ts` and `packages/devkit/src/utils/installed-version.ts`.
+
+```ts
+// version-floor.ts
+function throwForUnsupportedVersion(
+  packageName: string,
+  installedVersion: string,
+  floor: string
+): never;
+
+function assertSupportedPackageVersion(
+  tree: Tree,
+  packageName: string,
+  minSupportedVersion: string
+): void;
+```
+
+```ts
+// installed-version.ts
+function getInstalledPackageVersion(packageName: string): string | null;
+
+function getDeclaredPackageVersion(
+  tree: Tree,
+  packageName: string,
+  latestKnownVersion?: string
+): string | null;
+
+const NON_SEMVER_DIST_TAGS = ['latest', 'next'] as const;
+function isNonSemverDistTag(version: string): version is NonSemverDistTag;
+function normalizeSemver(version: string): string | null;
+```
+
+When to use which:
+
+| Context                          | Function                                                                            |
+| -------------------------------- | ----------------------------------------------------------------------------------- |
+| Generator entry (assert floor)   | `assertSupportedPackageVersion(tree, pkg, floor)`                                   |
+| Generator-time version branching | `getDeclaredPackageVersion(tree, pkg, latestKnownVersion)`                          |
+| Executor / runtime / preset      | `getInstalledPackageVersion(pkg)`                                                   |
+| Anywhere                         | `isNonSemverDistTag`, `normalizeSemver`                                             |
+| Never                            | `throwForUnsupportedVersion` directly — it's an implementation detail of the assert |
+
+### `@nx/devkit/internal-testing-utils`
+
+Source: `packages/nx/src/internal-testing-utils/assert-generators-enforce-version-floor.ts`.
+
+```ts
+function assertGeneratorsEnforceVersionFloor(options: {
+  packageRoot: string;
+  packageName: string;
+  subFloorVersion: string;
+  excludeGenerators?: string[];
+}): void;
+```
+
+Behavior: reads `generators.json` from `packageRoot`, iterates every entry, loads its factory, calls it against a tree with `{ [packageName]: subFloorVersion }` in `package.json`, expects a throw matching `Unsupported version of \`${packageName}\` detected`.
+
+`excludeGenerators` is only for intentional sub-floor migrators (e.g., `migrate-to-cypress-11`). Comment the reason next to the array.
+
+## Finding the existing floor (audit input)
+
+When auditing a plugin you haven't touched before, the floor may not be declared in one place. Check, in order of authority:
+
+1. **`minSupported<Pkg>Version` constant in `versions.ts`** — if it exists, that's the declared floor.
+2. **`peerDependencies` lowest range in `package.json`** — what the plugin advertises supporting.
+3. **Lowest major in `versionMap` / `backwardCompatibleVersions` / `supportedVersions`** — what the plugin has install lanes for.
+4. **Lowest `packageJsonUpdates` entry that touches the third-party package** — historical evidence of the supported range.
+5. **Highest API requirement in the plugin's own code (the _effective_ floor).** Grep for every `import` / `require` from the third-party package and identify which APIs are called. Cross-reference each against the third-party's changelog. The plugin's effective floor is the lowest major where **all** called APIs exist. **This trumps the declared floor** — if `versions.ts` claims v2 but the plugin imports an API only available in v3+, the declared floor is wrong.
+
+These should agree. When they don't, the disagreement is the finding (phantom peer claim, drifted versionMap, declared floor below effective floor).
+
+**Worked example:** During open PR `#35671`, the audit initially landed on a `v2.0.0` floor (matching the lowest install lane). Then a follow-up commit dropped the floor to `v3.0.0` after noticing the plugin's atomization code calls `getRelevantTestSpecifications`, which is a vitest v3+ API. Lesson: step 5 above is not optional. Always check what APIs the plugin's own runtime code uses — `versions()` having a v2 lane doesn't mean the plugin actually works on v2.
+
+## The plugin wrapper (one per plugin)
+
+Path: `packages/<plugin>/src/utils/assert-supported-<pkg>-version.ts`.
+
+Two canonical shapes:
+
+### Single-major floor (most plugins)
+
+```ts
+import { type Tree } from '@nx/devkit';
+import { assertSupportedPackageVersion } from '@nx/devkit/internal';
+import { minSupportedCypressVersion } from './versions';
+
+export function assertSupportedCypressVersion(tree: Tree): void {
+  assertSupportedPackageVersion(tree, 'cypress', minSupportedCypressVersion);
+}
+```
+
+Reference: `packages/cypress/src/utils/assert-supported-cypress-version.ts`, `packages/playwright/src/utils/assert-supported-playwright-version.ts`.
+
+### Floor derived from supported-versions list (angular)
+
+```ts
+import { type Tree } from '@nx/devkit';
+import { assertSupportedPackageVersion } from '@nx/devkit/internal';
+import { supportedVersions } from './backward-compatible-versions';
+
+const minSupportedAngularMajor = Math.min(...supportedVersions);
+
+export function assertSupportedAngularVersion(tree: Tree): void {
+  assertSupportedPackageVersion(
+    tree,
+    '@angular/core',
+    `${minSupportedAngularMajor}.0.0`
+  );
+}
+```
+
+Reference: `packages/angular/src/utils/assert-supported-angular-version.ts`.
+
+Pick the shape that matches whether the plugin already has a `supportedVersions` list (angular does; cypress/playwright/vitest don't).
+
+### Plugins managing multiple primary packages
+
+`@nx/jest` manages `jest`, `ts-jest`, `@types/jest`. `@nx/eslint` manages `eslint`, `@typescript-eslint/parser`, `@typescript-eslint/eslint-plugin`, `eslint-config-prettier`. The canonical wrapper signature takes one package; with multiple, decisions are needed:
+
+- **Gate on the primary only** when the others are peer-locked (e.g., angular's strategy with `@angular/core` covering `@angular/cli`, `@angular/ssr`, etc.). This is sufficient when the siblings' peer-deps tie them to the primary's major.
+- **Gate on each independently** when the siblings can be installed at any major regardless of the primary (typescript-eslint pair vs eslint; ts-jest vs jest). In that case, the wrapper makes multiple `assertSupportedPackageVersion` calls in sequence:
+
+```ts
+export function assertSupportedJestVersion(tree: Tree): void {
+  assertSupportedPackageVersion(tree, 'jest', minSupportedJestVersion);
+  // ts-jest is independent — declare and assert it separately.
+  assertSupportedPackageVersion(tree, 'ts-jest', minSupportedTsJestVersion);
+}
+```
+
+When in doubt: read each sibling's `peerDependencies` block at the version range being supported. If it pins the primary, it's covered by the primary's gate. If it doesn't (or pins something else), it needs its own.
+
+## Skip writing the install constant when the package is already detected
+
+Init generators that add the third-party package to `package.json` should NOT overwrite an already-installed minor/patch. The `keepExistingVersions: true` flag handles this at the `addDependenciesToPackageJson` level. But for code paths that compute the version to write (e.g., picking the major-specific value from `versionMap`), the rule is the same: read what's installed first; only write the fresh-install constant when nothing is detected.
+
+Reference: `packages/cypress/src/generators/init/init.ts` `updateDependencies` — calls `getInstalledCypressVersion(tree)` first, then routes through `versions(tree)` which short-circuits to existing-version paths. The `keepExistingVersions ?? true` flag at the `addDependenciesToPackageJson` call site is the final safety net.
+
+## The versions module
+
+Path: `packages/<plugin>/src/utils/versions.ts`.
+
+### Required exports
+
+```ts
+// Plain string, no caret. Used as the floor for assertSupportedPackageVersion.
+export const minSupportedCypressVersion = '13.0.0';
+
+// Fresh-install constants — may be HIGHER than minSupported when the feature
+// surface at the floor is incomplete. Playwright peer is ^1.36.0 but
+// fresh-install is ^1.37.0 so blob reporter + merge-reports work out of the
+// box.
+export const playwrightVersion = '^1.37.0';
+
+// Optional: feature-gate thresholds for runtime/executor code.
+export const minPlaywrightVersionForBlobReports = '1.37.0';
+```
+
+### Stable deps stay top-level; per-major-varying deps go in the bundle
+
+A plugin typically manages one primary package whose version map drives several siblings. Deps that vary per major go into a typed bundle; deps that are version-stable stay as plain `export const`s.
+
+```ts
+// Stable across all supported majors of the primary → plain exports.
+export const viteVersion = '^8.0.0';
+export const jsdomVersion = '^27.1.0';
+export const vitePluginReactVersion = '^6.0.0';
+
+// Vary with the primary's major → bundle.
+export const vitestVersion = '~4.1.0';
+export const vitestCoverageV8Version = '~4.1.0';
+export const vitestCoverageIstanbulVersion = '~4.1.0';
+
+type VitestVersions = {
+  vitestVersion: string;
+  vitestCoverageV8Version: string;
+  vitestCoverageIstanbulVersion: string;
+};
+
+// latestVersions reuses the top-level exports so import { vitestVersion }
+// stays valid for the fresh-install path while versions(tree).vitestVersion
+// is the route-aware version.
+const latestVersions: VitestVersions = {
+  vitestVersion,
+  vitestCoverageV8Version,
+  vitestCoverageIstanbulVersion,
+};
+
+type CompatVersions = 3;
+const versionMap: Record<CompatVersions, VitestVersions> = {
+  3: {
+    vitestVersion: '^3.0.0',
+    vitestCoverageV8Version: '^3.0.5',
+    vitestCoverageIstanbulVersion: '^3.0.5',
+  },
+};
+```
+
+**Do not** keep per-major aliases like `vitestV3Version = '^3.0.0'` alongside the bundle — they duplicate the map entries and drift over time. See `anti-patterns.md` §15.
+
+### The `versions(tree)` function
+
+Falls through to latest on unknown majors — no `switch + throw default:`.
+
+```ts
+export function versions(tree: Tree): VitestVersions {
+  const installedVitestVersion = getInstalledVitestVersion(tree);
+  if (!installedVitestVersion) {
+    return latestVersions;
+  }
+  const vitestMajorVersion = major(installedVitestVersion);
+  return versionMap[vitestMajorVersion as CompatVersions] ?? latestVersions;
+}
+```
+
+### The `getInstalled<Pkg>Version(tree?)` helper
+
+Optional `tree` parameter — with tree, reads declared from `package.json` via `getDeclaredPackageVersion` (handles dist-tag normalization, semver cleaning); without tree, routes through `getInstalledPackageVersion` from `@nx/devkit/internal` (FS resolution via `getNxRequirePaths()`).
+
+**Do not open-code the tree-branch.** `getDeclaredPackageVersion` already centralizes the dist-tag list (`isNonSemverDistTag`) and the `clean(v) ?? coerce(v)?.version ?? null` chain (`normalizeSemver`). Local re-implementations drift when devkit's constants change. See `anti-patterns.md` §1.
+
+```ts
+import { type Tree } from '@nx/devkit';
+import {
+  getDeclaredPackageVersion,
+  getInstalledPackageVersion,
+} from '@nx/devkit/internal';
+import { major } from 'semver';
+
+export function getInstalledVitestVersion(tree?: Tree): string | null {
+  if (!tree) {
+    return getInstalledPackageVersion('vitest');
+  }
+  return getDeclaredPackageVersion(tree, 'vitest');
+}
+
+export function getInstalledVitestMajorVersion(tree?: Tree): number | null {
+  const installedVitestVersion = getInstalledVitestVersion(tree);
+  return installedVitestVersion ? major(installedVitestVersion) : null;
+}
+```
+
+Reference: `packages/cypress/src/utils/versions.ts`, `packages/rspack/src/utils/version-utils.ts`, `packages/rsbuild/src/utils/version-utils.ts`.
+
+#### Dist-tag semantics — third arg (`latestKnownVersion`)
+
+`getDeclaredPackageVersion(tree, pkg, latestKnownVersion?)`'s third arg falls back to `normalizeSemver(latestKnownVersion)` whenever the declared range can't be normalized to semver — both "package missing from `package.json`" AND "package declared as a dist tag (`latest` / `next`)". The helper does not distinguish the two cases.
+
+**Default to omitting the third arg.** The wrapper returns `null` for both "missing" and "dist tag"; consumers that want `?? latestVersions` semantics should encode it at the call site (rspack/rsbuild precedent), not globally in the helper. Passing the third arg makes the helper claim the package is "installed at the fresh-install constant" even when nothing is declared — which silently disables init generators' "add the package" branches.
+
+When a consumer specifically needs to distinguish "missing" from "dist tag", use `getDependencyVersionFromPackageJson` from `@nx/devkit` to inspect the raw declared string.
+
+## Generator entry points
+
+The assert goes in the function that does the actual work — first statement of the function body, before any other tree access or sub-generator call. (The assert itself reads the tree, of course; the rule is that nothing else in the generator runs against an unsupported version.)
+
+### Plugins with a `<gen>` / `<gen>Internal` split (cypress, playwright)
+
+The public wrapper merges defaults and delegates. Assert lives in `*Internal`:
+
+```ts
+// Public wrapper — no assert, just default merging.
+export async function cypressInitGenerator(tree: Tree, options: Schema) {
+  return cypressInitGeneratorInternal(tree, { addPlugin: false, ...options });
+}
+
+// Working function — assert is the first statement.
+export async function cypressInitGeneratorInternal(
+  tree: Tree,
+  options: Schema
+) {
+  assertSupportedCypressVersion(tree);
+
+  updateProductionFileset(tree);
+  // ...
+}
+```
+
+Reference: `packages/cypress/src/generators/init/init.ts`, `packages/playwright/src/generators/init/init.ts`.
+
+### Plugins with a single-function generator (angular)
+
+No wrapper/internal split. The function itself asserts:
+
+```ts
+export async function angularInitGenerator(tree: Tree, options: Schema) {
+  assertSupportedAngularVersion(tree);
+  // ...
+}
+```
+
+Reference: `packages/angular/src/generators/init/init.ts`.
+
+### Double-asserts are established convention, not an edge case
+
+When `configurationGenerator` calls `initGenerator` internally, both call their respective `assertSupportedXVersion`. This is the angular precedent (29 `generators.json` entries → 58 assert call sites). The assert is idempotent (one tree read + one semver comparison) and the parameterized floor spec treats every entry point as independent — both must throw on sub-floor. Don't refactor away.
+
+## User-pin preservation
+
+### `addDependenciesToPackageJson` call sites
+
+Every call from a generator (NOT a migration) must pass `keepExistingVersions: true` as the fifth positional argument or via the `?? true` pattern.
+
+```ts
+// Pattern A — explicit at the call site
+addDependenciesToPackageJson(
+  tree,
+  {},
+  { 'eslint-plugin-cypress': pkgVersions.eslintPluginCypressVersion },
+  undefined,
+  true
+);
+
+// Pattern B — driven by schema (init generators only)
+addDependenciesToPackageJson(
+  tree,
+  {},
+  devDependencies,
+  undefined,
+  options.keepExistingVersions ?? true
+);
+```
+
+Reference: `packages/cypress/src/generators/init/init.ts`, `packages/cypress/src/utils/add-linter.ts`, `packages/angular/src/generators/add-linting/lib/add-angular-eslint-dependencies.ts`.
+
+### init schema
+
+```json
+{
+  "keepExistingVersions": {
+    "type": "boolean",
+    "x-priority": "internal",
+    "description": "Keep existing dependencies versions",
+    "default": true
+  }
+}
+```
+
+Reference (on master): `packages/cypress/src/generators/init/schema.json`, `packages/playwright/src/generators/init/schema.json`. (`@nx/vitest` follows the same pattern in its open PR — verify via `gh pr diff 35671`.)
+
+## Migrations.json gates
+
+Three categories of migration:
+
+| Category                         | Touches                                           | `requires`                                                                  |
+| -------------------------------- | ------------------------------------------------- | --------------------------------------------------------------------------- |
+| Nx-only                          | `nx.json`, executor options, generator defaults   | none                                                                        |
+| Codemod                          | source files / config tied to a third-party major | `{ "<pkg>": ">=N <N+1" }` (or open upper bound for legacy-cleanup codemods) |
+| `packageJsonUpdates` cross-major | bumps `<pkg>` from major N to N+1                 | `{ "<pkg>": ">=N.0.0 <(N+1).0.0" }` (source-major gate)                     |
+| `packageJsonUpdates` same-major  | bumps minor/patch                                 | none required                                                               |
+
+### Sibling packages
+
+Ecosystem-locked siblings whose peer-on-the-primary covers them: no separate `requires`. Examples in Angular: `@angular/cli`, `@angular/ssr`, `@angular-devkit/build-angular` (from v20+, NOT v19).
+
+Independent siblings: each needs its own `requires` entry. Examples in Angular: `@ngrx/*`, `@angular-eslint/*`, `zone.js`, `jest-preset-angular`.
+
+### Reference examples
+
+- `packages/angular/migrations.json` `20.2.0-module-federation`, `22.2.0`, `22.6.0-module-federation` — Module Federation entries gating on `@module-federation/enhanced` source range. Added in `#35587`.
+- `@nx/vitest`'s `update-22-1-0` and `update-22-3-2` migrations gating on `vitest: ">=4.0.0"` (Vitest-4-specific AI-instructions) — pattern proposed in open PR `#35671`. Inspect via `gh pr diff 35671 --repo nrwl/nx -- packages/vitest/migrations.json`.
+- `packages/angular/migrations.json` `update-unit-test-runner-option` — Nx-only migration with the over-gating `@angular/core` `requires` **removed** in `#35587`.
+
+## Test specs
+
+### Parameterized floor spec (one per plugin)
+
+Path: `packages/<plugin>/src/utils/all-generators-enforce-floor.spec.ts`.
+
+```ts
+import { assertGeneratorsEnforceVersionFloor } from '@nx/devkit/internal-testing-utils';
+import { join } from 'node:path';
+
+describe('@nx/<plugin> generators enforce supported version floor', () => {
+  assertGeneratorsEnforceVersionFloor({
+    packageRoot: join(__dirname, '..', '..'),
+    packageName: '<pkg>',
+    subFloorVersion: '~<floor-minus-one>',
+    // Required only when a generator must run below the floor by design.
+    // excludeGenerators: ['migrate-to-cypress-11'],
+  });
+});
+```
+
+Pick `subFloorVersion` such that `lt(coerce(it).version, floor)` is true. No pre-release identifiers. Reference values used in the repo: `~18.2.0` (angular, v19 floor), `~12.17.0` (cypress, v13 floor), `~1.35.0` (playwright, v1.36 floor).
+
+### Plugin assert spec (optional, one per plugin)
+
+Path: `packages/<plugin>/src/utils/assert-supported-<pkg>-version.spec.ts`.
+
+`assertSupportedPackageVersion` is already fully tested in `@nx/devkit`,
+so a per-plugin spec mostly re-tests the shared helper. The early
+compliance PRs (`#35587` angular onward) ship one for symmetry, but it
+isn't required. If you add one, five canonical cases is the shape used:
+
+```ts
+describe('assertSupportedCypressVersion', () => {
+  it('throws when cypress is below the supported floor');
+  it('does not throw when cypress is not installed (fresh-install path)');
+  it('does not throw when cypress is `latest`');
+  it('does not throw when cypress is `next`');
+  it('does not throw when cypress is within the supported window');
+});
+```
+
+Reference: `packages/angular/src/utils/assert-supported-angular-version.spec.ts` (originally landed in `#35587`).
+
+### Test message matching
+
+Use substring match on the error message:
+
+```ts
+.rejects.toThrow(`Unsupported version of \`${packageName}\` detected`)
+```
+
+Not a hand-rolled RegExp (avoid escape bugs). Reference: see how the shared `assertGeneratorsEnforceVersionFloor` itself does the match — search for `Unsupported version of` in `packages/nx/src/internal-testing-utils/assert-generators-enforce-version-floor.ts`.
+
+## Standardized error format
+
+```
+Unsupported version of `<pkg>` detected.
+
+  Installed: <declared-range-as-written-in-package.json>
+  Supported: >= <floor>
+
+Update `<pkg>` to <floor> or higher.
+```
+
+Two notes:
+
+- The `Installed:` line preserves the **original declared range** (e.g., `~18.2.0`), not the cleaned semver. `assertSupportedPackageVersion` passes `declared` through to `throwForUnsupportedVersion`.
+- Do not add an "above ceiling" branch to this message. Above-ceiling is silent fallthrough.
+
+## Peer dep alignment
+
+### What belongs in `peerDependencies`
+
+The test: _would the plugin still work if this package were absent from the workspace, with the plugin's code paths unchanged?_
+
+A package is required-peer if **any** of these is true:
+
+- The plugin's TypeScript imports / `require`s it (executor, preset, runtime helper).
+- The plugin's executor spawns its CLI binary (`spawn('cypress')`, etc.).
+- The plugin's inferred plugin (`createNodes`/`createNodesV2`) **emits a target whose `command` invokes the package's CLI** (e.g., `command: 'rspack build'` → `@rspack/cli` is required). The `externalDependencies: ['<pkg>']` declaration in such targets is itself an admission of the runtime dependency.
+
+A package is **not** required-peer when:
+
+- The plugin's generator installs it into the user's workspace for the user to consume independently, and no plugin code (TypeScript, executor binary spawn, or inferred-plugin emitted command) ever invokes it. Example: ESLint plugins written into the user's eslintrc — `@nx/cypress` installs `eslint-plugin-cypress`, but its lint executor uses generic ESLint loading; the cypress plugin is loaded by ESLint per the user's config, not by `@nx/cypress`. Example: `@types/*` packages installed for the user's TS compilation but never imported by plugin code.
+
+**Ecosystem-signal peer** (Angular's full `@angular/*` peer list) → judgment call, not a compliance requirement. Documents lockstep compatibility but isn't enforced by the multi-version rules.
+
+### Required vs. optional peer
+
+Most Nx plugin peers should be **optional** (`peerDependenciesMeta: { "<pkg>": { "optional": true } }`):
+
+- Required peer: every user of the plugin needs this package, regardless of which surface they use. Example: `@angular-devkit/core`, `rxjs` in `@nx/angular` — every Angular Nx workspace uses them.
+- **Optional peer (the common case for inferred-plugin / executor surfaces):** the package is only needed when the user opts into a specific surface — an executor they have to write into `project.json`, an inferred plugin gated on the presence of a config file, a preset that auto-injects. Users who don't use that surface shouldn't see an unmet-peer warning. Examples: `@playwright/test` in `@nx/playwright`, `cypress` in `@nx/cypress`, `vitest` / `vite` in `@nx/vitest`, `@angular/build` / `@angular-devkit/build-angular` / `ng-packagr` in `@nx/angular`.
+
+For `@rspack/cli` / `@rspack/core` in `@nx/rspack`: both surfaces (executor, inferred plugin) are gated — executor opt-in via `project.json`, inferred plugin gated on `rspack.config.{ts,js}` presence. Compliance fix should peer-declare both with `optional: true`.
+
+Concrete examples:
+
+| Package                 | Plugin           | Plugin invokes?                                                                                                                                                  | Peer?   | Optional?                                             |
+| ----------------------- | ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------- | ----------------------------------------------------- |
+| `cypress`               | `@nx/cypress`    | yes (executor spawns binary; inferred plugin emits `cypress run` commands)                                                                                       | **yes** | optional (executor + inferred plugin are both opt-in) |
+| `@playwright/test`      | `@nx/playwright` | yes (executor + preset + inferred plugin)                                                                                                                        | **yes** | optional                                              |
+| `vitest`                | `@nx/vitest`     | yes (executor + inferred plugin emits `vitest` commands)                                                                                                         | **yes** | optional                                              |
+| `@rspack/cli`           | `@nx/rspack`     | yes — inferred plugin emits `command: 'rspack build'` (`packages/rspack/src/plugins/plugin.ts:182,196`). Not imported in TS, but invoked via emitted CLI target. | **yes** | optional (both surfaces gated)                        |
+| `@angular-devkit/core`  | `@nx/angular`    | yes (used by every Angular Nx workspace)                                                                                                                         | **yes** | **not optional**                                      |
+| `@angular/build`        | `@nx/angular`    | yes (only when user uses the @angular/build builder)                                                                                                             | **yes** | optional                                              |
+| `eslint-plugin-cypress` | `@nx/cypress`    | no (generator writes it into user's eslintrc; ESLint loads it, not the plugin)                                                                                   | **no**  | n/a                                                   |
+| `@types/node`           | various          | no (generator install only; types are build-time)                                                                                                                | **no**  | n/a                                                   |
+
+### Range / version alignment
+
+For packages that ARE peer-declared: the range must match the install lanes the code ships. If the code has no `isV1Installed` branch and no v1 entry in `versionMap`, do not list `^1.0.0` in the peer range.
+
+Reference: open PR `#35671` (`@nx/vitest`) drops `^1.0.0` from the `vitest` peer range because there is no v1 install lane. Inspect via `gh pr diff 35671 --repo nrwl/nx -- packages/vitest/package.json`. Verify state — may have merged or closed since.
+
+## Executor / runtime feature gating
+
+Features introduced after the floor must gate at call time on the installed version, not on the floor. Use `getInstalledPackageVersion` + `lt` from `semver`.
+
+```ts
+import { getInstalledPackageVersion } from '@nx/devkit/internal';
+import { lt } from 'semver';
+import { minPlaywrightVersionForBlobReports } from './versions';
+
+const installed = getInstalledPackageVersion('@playwright/test');
+if (installed && lt(installed, minPlaywrightVersionForBlobReports)) {
+  throw new Error(
+    `The "@nx/playwright:merge-reports" executor requires "@playwright/test" version ${minPlaywrightVersionForBlobReports} or greater (the version that introduced the "blob" reporter and the "merge-reports" CLI). You are currently using version ${installed}.`
+  );
+}
+```
+
+Reference: `packages/playwright/src/executors/merge-reports/merge-reports.impl.ts`, `packages/playwright/src/utils/preset.ts`. Both added in `#35642`.
+
+Two distinct cases:
+
+- **Auto-injected feature** (preset's auto-blob in CI): skip injection silently when installed < threshold. Only throw when the user explicitly opted in (`generateBlobReports: true`) on an unsupported version.
+- **Direct invocation** (executor CLI subcommand): throw immediately with a clear "requires >= X.Y.Z (the version that introduced …)" message.
+
+## File-layout summary
+
+For plugin `@nx/<plugin>` managing `<pkg>` with floor `X.Y.Z`:
+
+```
+packages/<plugin>/
+  src/
+    utils/
+      versions.ts                                # add minSupportedXVersion
+      assert-supported-<pkg>-version.ts          # NEW — 7-line wrapper
+      assert-supported-<pkg>-version.spec.ts     # OPTIONAL — 5 cases (mostly re-tests shared helper)
+      all-generators-enforce-floor.spec.ts       # NEW — parameterized
+    generators/
+      <each>/
+        <each>.ts                                # assert as first statement
+      init/
+        schema.json                              # keepExistingVersions default: true
+        init.ts                                  # keepExistingVersions ?? true
+    executors/                                   # feature-gate via getInstalledPackageVersion
+    plugins/                                     # same
+  migrations.json                                # tighten / remove `requires` gates per audit
+  package.json                                   # align peer; add "semver": "catalog:" if newly used
+```
+
+---
+
+# Code-level verification (review-mode lens)
+
+In review mode, walk these markers against the diff.
+
+Output rules:
+
+- **Inline categories are `[blocker]` and `[non-blocker]` only.** No "open question," "ask," or other ad-hoc tags. Author-directed questions emerge from non-blocker findings and surface in the closing "Open questions for author" block.
+- **For each blocker / non-blocker:** anchor at `file:line` and cite which reference PR / file demonstrates the correct pattern. Cross-reference `anti-patterns.md` when the finding matches a numbered pattern.
+- **Sections without findings get a single summary line**, not a per-file enumeration. `"Pass — all 7 generator entries assert at first statement"` is right; listing seven file:lines is wrong. Reviewer time is spent on actionable items; passing checks should not eat reading budget.
+- **Produce the verdict block** at the end (see §"Verdict template"). The block is the skimmable index — produce it, don't substitute a free-form summary.
+
+Scope:
+
+- **In scope:** the diff's code, configs, schemas, migrations, and **in-codebase documentation that describes runtime behavior** (e.g., `.mdoc` / `.md` files under `astro-docs/` or `docs/` that claim how the plugin behaves). A docs claim that contradicts the code is a correctness issue and belongs here.
+- **Out of scope:** PR title, PR body shape, commit message format, related-issues section, branch naming. Defer to the user's PR/commit conventions (loaded globally from `~/.claude/memory/workflow/git/`). Don't flag PR/commit shape in this skill's review output.
+
+## 1. Peer dep & install constants
+
+- [blocker] `package.json` peer dep range matches the install lanes implemented in `versions.ts`. No phantom version claims. → If `versionMap` has no v1 entry, peer must not list `^1.0.0`. Reference correction: `#35671` (`@nx/vitest`). Anti-pattern: §8.
+- [blocker] **Declared floor matches the effective floor.** Grep every `import` / `require` from the third-party package in plugin code. If any imported API only exists at version >N, the declared floor must be >=N. Anti-pattern: §16. Reference correction: `#35671` second commit raised vitest from v2 to v3 after catching a `getRelevantTestSpecifications` import (v3+ only).
+- [blocker] Fresh-install constant exposes the **full feature surface**, not just the peer floor. → Playwright peer stayed `^1.36.0` but fresh-install moved to `^1.37.0` because blob reporter + `merge-reports` CLI both require 1.37. Reference: `#35642` `packages/playwright/src/utils/versions.ts`.
+- [blocker] No per-major version aliases (`<pkg>V3Version`, `<pkg>V4Version`, etc.) alongside a `versionMap` — pick one source of truth. Anti-pattern: §15. Reference: `#35671`'s third commit dropped these aliases.
+- [blocker] `versions.ts` exports `minSupportedXVersion = 'X.Y.Z'` as a plain string (no caret, no range markers). The wrapper passes this verbatim to `assertSupportedPackageVersion`.
+- [blocker] `versionMap[major]` lookup is `versionMap[major] ?? latestVersions`. No `switch + throw default:` or other above-ceiling throw. Anti-pattern: §2. Reference correction: `#35670` (`@nx/cypress` `versions()` rewrite).
+- [blocker] Every third-party package the **plugin invokes at runtime** has a `peerDependencies` entry. "Invokes" covers: (a) TypeScript `import`/`require`, (b) executor spawning the package's CLI binary, (c) inferred-plugin (`createNodes`/`createNodesV2`) emitting a target whose `command` invokes the package's CLI (the `externalDependencies: ['<pkg>']` field on such targets confirms the dependency). See §"Peer dep alignment" for the full categorization.
+  - **Don't flag** packages the plugin's generator installs into the user's workspace for the user to consume independently, with no plugin codepath invoking them (e.g., ESLint plugins like `eslint-plugin-cypress` that ESLint loads from the user's eslintrc; `@types/*` packages).
+  - Plugins flagged at time of writing for actually-invoked packages without a peer entry: `@nx/webpack`, `@nx/rollup`, `@nx/angular-rspack-compiler` (primary listed under `dependencies`); `@nx/jest`, `@nx/nest`, `@nx/module-federation`, `@nx/react`, `@nx/vue`, `@nx/expo`, `@nx/react-native`, `@nx/node`, `@nx/js` (verify per plugin — TS imports, binary spawns, AND inferred-plugin emitted commands all count).
+- [blocker] Peers that are only used when the user opts into a specific surface (executor opt-in, inferred plugin gated on config file presence, opt-in preset) are declared **optional** via `peerDependenciesMeta: { "<pkg>": { "optional": true } }`. Pattern is established across reference plugins — `@playwright/test`, `cypress`, `vitest`, `vite`, `@angular/build`, `ng-packagr` are all optional. Required-non-optional peers (`@angular-devkit/core`, `rxjs` in `@nx/angular`) are reserved for packages every workspace using the plugin needs. See §"Required vs. optional peer".
+- [non-blocker] If the PR introduces `semver` usage in the plugin, `package.json` `dependencies` lists `"semver": "catalog:"`. Reference: `#35642` added it to `packages/playwright/package.json`.
+
+## 2. Generator entry points
+
+- [blocker] **Every** entry in `generators.json` has its working function calling `assertSupported<Pkg>Version(tree)` as the **first statement** — before any tree reads, writes, or sub-generator calls. For wrapper/internal-split plugins (cypress, playwright): assert is in `*Internal`. For single-function generators (angular): in the function itself. Anti-pattern: §14.
+- [blocker] Plugin wrapper file `assert-supported-<pkg>-version.ts` imports `assertSupportedPackageVersion` from `@nx/devkit/internal`. No direct call to `throwForUnsupportedVersion`. No bespoke `throwBelowFloor` / `throwAboveWindow` / `assertVersion` / local `cleanVersion = clean(v) ?? coerce(v)?.version` helpers (use `normalizeSemver` / `getInstalledPackageVersion` / `getDeclaredPackageVersion`). Anti-pattern: §1. Concrete example: PR `#35676` introduces a local `cleanVersion` and `getInstalledRsbuildVersionRuntime` — both already exist as shared helpers.
+- [blocker] If `all-generators-enforce-floor.spec.ts` uses `excludeGenerators`, each excluded name has a code comment explaining why the generator must run sub-floor (e.g., `migrate-to-cypress-11` lifts v8–v10 workspaces onto v11).
+- [non-blocker] Double-assert chains (`configurationInternal` calls `initInternal`, both assert) are OK. Idempotent. Don't refactor away.
+
+## 3. Generator outputs
+
+- [blocker] Templates the generator writes (project files, configs, schemas) compile and run on every major in the support window. Verify with a quick mental walk: for each template referenced from the generator, identify any per-major-version conditional and confirm it's accurate.
+- [blocker] Generated `project.json` target shape (executor, options, schema) is valid on every supported major. If the executor's option schema differs across the support window, the generator branches or uses the union shape.
+- [blocker] Default option values are valid on every supported major. A default that's only valid above a specific major must be conditional.
+- [blocker] Version map covers every managed third-party dep. If the runtime later branches on a sibling's version (e.g., `@vitest/ui`), the version map must have an entry for that sibling per major — no gaps where the generator picks a constant the runtime then can't reconcile.
+- [blocker] Generator schema accepts the **union of options across the support window**. Options removed in a newer major still validate at schema level (with description-notice); runtime throws when inapplicable on the installed major. See `gotchas.md` §"Schema-level deprecated-option stubs with runtime throws".
+
+## 4. `keepExistingVersions` (user-pin preservation)
+
+- [blocker] Every `addDependenciesToPackageJson` call from a **generator** passes `keepExistingVersions: true` (positionally as the 5th arg) or `options.keepExistingVersions ?? true`.
+- [blocker] `init/schema.json` has `"keepExistingVersions": { "default": true }`. Not `false`. Not absent. **Known gap:** `@nx/angular`'s init schema currently has `default: false` and was NOT addressed in `#35587` — flagging in a non-angular PR is correct; fixing in passing in an angular PR is also correct. Anti-pattern: §4.
+- [blocker] Linter / sub-generator helpers (`add-linter.ts`, `add-angular-eslint-dependencies.ts`, equivalents) also pass `true`.
+- [non-blocker] If both schema `"default": true` AND `options.keepExistingVersions ?? true` are present, that's two sources of truth. Anti-pattern: §12.
+- **Migration generators are exempt.** Do not flag missing flags in code under `src/migrations/`.
+
+## 5. `migrations.json` gates
+
+- [blocker] Every `packageJsonUpdates` entry that bumps across a major version has `requires: { "<pkg>": ">=N.0.0 <(N+1).0.0" }`. Source-major gate, not target. Anti-pattern: §6. Reference: `#35587` Module Federation entries.
+  - **Read the actual range strings; don't tick this by counting split entries.**
+  - [non-blocker / ask author] One-sided gates (`<X` with no lower bound, or `>=Y` with no upper bound) may be intentional or accidental. Legitimate cases: legacy-cleanup codemods that should apply on every source major below the target; a v0→v1 bridge where every v0.x workspace should migrate; bumping a package introduced at vN from `undefined`. Illegitimate cases: a v1→v2 bump expressed as `<2.x` would fire for v0 workspaces too; a `>=N` with no upper bound would fire for future majors. **When you see a one-sided gate, ask the author to confirm intent** — don't auto-flag as blocker.
+- [blocker] Codemod migrations that only make sense at/above a specific third-party major have a `requires` entry. Open upper bound is intentional when the codemod cleans up legacy flags. Runtime per-package guards (`gte`/`lt` inside the migration body) are NOT a substitute for `requires`.
+- [blocker] **Nx-only migrations have NO `requires` gate.** A migration that only writes to `nx.json`, executor options, or generator defaults applies regardless of third-party version. Anti-pattern: §5. Reference correction: `#35587` removed the over-gating `@angular/core: >=21.0.0` from `update-unit-test-runner-option`.
+- [blocker] For independent siblings (Angular: `@ngrx/*`, `@angular-eslint/*`, `zone.js`, `jest-preset-angular`), gating on the primary's major is **not sufficient** — each needs its own `requires` entry. Anti-pattern: §7. Verify pairing by reading the sibling's `peerDependencies` at the version range being bumped from.
+- [blocker] A single `packageJsonUpdates` entry must not mix mutually-exclusive cross-major bumps under one `requires` (AND-semantics). Split into separate entries each with its own gate. Concrete example: React PR's `22.3.4` entry mixed `react-router 7.12.0` (cross-major) with `react-router-dom 6.30.3` (v6 patch) — must split.
+- [non-blocker] `incompatibleWith` is not a substitute for `requires`. Anti-pattern: §10. If you see `incompatibleWith` standing in for a source-major gate, ask for a `requires` instead.
+- [non-blocker] Sibling `packageJsonUpdates` entries within the same block that depend on a peer's post-bump version are fine — tier-1 chaining evaluates against post-bump state. Reference: Storybook 21.2.0 chains on the prior 21.1.0 bump.
+- [non-blocker] Pre-floor `packageJsonUpdates` entries targeting source majors below the current support floor are intentionally retained for users on older Nx versions. Don't _add_ a bridge entry without explicit decision, and don't _remove_ a legitimately-pre-floor entry mid-audit.
+
+## 6. Executor / runtime / inferred-plugin feature gating
+
+- [blocker] Executor code that invokes a CLI subcommand or uses an API introduced after the floor calls `getInstalledPackageVersion('<pkg>')` + `lt(installed, threshold)` from `semver` and throws a clear "requires >= X.Y.Z (the version that introduced …)" message. Reference: `packages/playwright/src/executors/merge-reports/merge-reports.impl.ts` (`#35642`).
+- [blocker] Preset / config builders that auto-inject feature-version-coupled config skip injection silently when installed < threshold, and only throw when the user **explicitly** opted in on an unsupported version. Reference: `packages/playwright/src/utils/preset.ts` (`#35642` — `generateBlobReports` logic).
+- [blocker] **Inferred plugins** (`createNodes`/`createNodesV2`) parse configs across every major in the support window. The plugin emits the same target shape regardless of the installed major (or branches if shapes diverge). Don't hardcode helper imports against one major.
+- [blocker] **Above-ceiling is silent fallthrough.** No warn, no throw, no branch. Anti-pattern: §2.
+- [non-blocker] Executors don't enforce the plugin floor. Floor enforcement is generator-only. Don't suggest adding an executor-level floor assert unless the user asks.
+- [non-blocker] `require('<pkg>')` for optional peers should live inside the function body, after version detection. Anti-pattern: §9.
+
+## 7. Tests
+
+- [blocker] `all-generators-enforce-floor.spec.ts` exists at `packages/<plugin>/src/utils/all-generators-enforce-floor.spec.ts`, calls `assertGeneratorsEnforceVersionFloor` from `@nx/devkit/internal-testing-utils`. This is the parameterized spec that exercises every generator's floor assert.
+- [blocker] `subFloorVersion` is a semver range where `lt(coerce(it).version, floor)` is true. No pre-release identifiers. Reference values: `~18.2.0` (angular, v19 floor), `~12.17.0` (cypress, v13 floor), `~1.35.0` (playwright, v1.36 floor).
+- [non-blocker] Plugins establishing the pattern (`#35587` angular) ship a `assert-supported-<pkg>-version.spec.ts` with the 5 canonical cases (sub-floor / fresh-install / `latest` / `next` / in-range). The underlying `assertSupportedPackageVersion` already has full coverage in `@nx/devkit`, so the per-plugin spec largely re-tests the shared helper. Useful for symmetry across the PR series but not required — don't block on missing.
+- [non-blocker] Runtime/executor feature-gate throw tests are nice-to-have, not required — reference PRs (`#35587`, `#35642`, `#35670`) do not have them today.
+- [non-blocker] Error message matching uses substring (`toThrow('Unsupported version of \`<pkg>\` detected')`) instead of hand-rolled `RegExp`. Anti-pattern: §13.
+- [non-blocker] FS-side helper migrated to `getInstalledPackageVersion`; tree-side helper may stay inline. The two helpers' `null` vs. fallback semantics differ. Reference: `#35670` `packages/cypress/src/utils/versions.ts` rewrite.
+
+## Open questions to raise (when missing from the PR / Linear task)
+
+1. **Floor:** deliberate raise from the previous declared peer, or matching the existing peer? If raise: do sub-floor users get a `packageJsonUpdates` bridge or manual bump?
+2. **Peer-range tightening:** dropping a major because there's no install lane (legitimate, `#35671` pattern) or because tests fail (regression risk — investigate)?
+3. **`requires` removals on Nx-only migrations:** genuinely Nx-only, or sneaking through a third-party-touching change?
+4. **Pruned migrations gaps:** if floor is being raised by N+ majors and prior `packageJsonUpdates` entries were removed, do sub-floor users have any auto-bump path? `git log --all -- packages/<plugin>/migrations.json`.
+5. **Runtime feature gates:** threshold verified against third-party release notes, or guessed?
+6. **Sibling classification:** ecosystem-locked vs. independent. Read the sibling's `peerDependencies` at the bumped-from range. `@angular-devkit/build-angular` is the gotcha — peer-locked from v20+, NOT v19.
+7. **Cross-plugin coordination:** if the plugin pins a third-party that another plugin also manages (e.g., `@nx/cypress` pinning vite for cypress v13/v14+; `@nx/vite` supporting vite v5–v8), confirm the windows stay aligned. If `@nx/vite` drops v5, `@nx/cypress` carries an orphaned install lane.
+
+## Verdict template
+
+```
+Blockers: <N>
+Non-blockers: <N>
+
+1. Peer dep & install constants: [pass | <findings>]
+2. Generator entry points: [pass | <findings>]
+3. Generator outputs: [pass | <findings>]
+4. keepExistingVersions: [pass | <findings>]
+5. Migration gates: [pass | <findings>]
+6. Executor / runtime / inferred-plugin: [pass | <findings>]
+7. Tests: [pass | <findings>]
+
+Open questions for author: [list]
+
+Scope drift vs. Linear task (if applicable):
+- Findings in task NOT addressed: <list>
+- Changes in PR NOT in task: <list>
+```

.claude/skills/multi-version-compliance/references/examples.md

@@ -0,0 +1,115 @@
+# Examples & references
+
+Concrete files, commits, and PRs to grep when you need a model.
+
+## Reference PRs (in order of arrival)
+
+| PR       | Plugin           | Branch     | State                   | Why notable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| -------- | ---------------- | ---------- | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `#35587` | `@nx/angular`    | `nxc-4381` | merged                  | First compliance PR. Established `throwForUnsupportedVersion`, the `assertSupported*Version` wrapper pattern, the `all-generators-enforce-floor.spec.ts` shape, the MF `requires`-gate pattern, the Nx-only-migration over-gate removal pattern.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `#35642` | `@nx/playwright` | `nxc-4398` | merged                  | Generalized the helpers into `version-floor.ts`/`installed-version.ts`. Added `assertGeneratorsEnforceVersionFloor` in `internal-testing-utils`. Established executor/runtime feature-gating pattern (blob reporter / `merge-reports`). Demonstrated the "fresh-install constant higher than peer floor" pattern.                                                                                                                                                                                                                                                                                                                                                                         |
+| `#35670` | `@nx/cypress`    | `nxc-4384` | merged                  | Established `excludeGenerators` in the shared test helper for intentional sub-floor migrators (`migrate-to-cypress-11`). Demonstrated `versions()` switch-to-fallthrough rewrite. Demonstrated keeping the tree-side inline helper while migrating only the FS side to the shared helper.                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `#35671` | `@nx/vitest`     | `nxc-4408` | open at time of writing | Three commits. (1) Establishes "drop phantom peer-range claim" (removes `^1.0.0` from peer); migration `requires` tightening for Vitest-4-only AI-instructions migrations. (2) Raises floor v2 → v3 after audit catches `getRelevantTestSpecifications` import (v3+ API) — establishes the **effective-floor-vs-declared-floor** pattern (see `anti-patterns.md` §16). (3) Adopts the cypress version-resolution pattern (bundle-of-varying-deps `versions(tree)`, `getInstalled<Pkg>Version(tree?)`, no per-major aliases — see `anti-patterns.md` §15). To inspect: `gh pr view 35671 --repo nrwl/nx --json commits` then `gh pr diff 35671`. Verify state — may have merged or closed. |
+
+Always verify state with `gh pr view <N> --repo nrwl/nx --json state` before citing — this table goes stale.
+
+## Reference commits (for `git show` inspection)
+
+When the same change exists as both a pre-squash branch commit AND a merged squash on master, prefer the merged squash — it's the authoritative final state. Pre-squash SHAs are listed because they're easier to read in isolation (smaller diffs) when investigating one specific aspect.
+
+**Merged on master (authoritative):**
+
+| SHA          | Subject                                                                      |
+| ------------ | ---------------------------------------------------------------------------- |
+| `75578724fa` | `cleanup(core): add throwForUnsupportedVersion util to @nx/devkit/internal`  |
+| `484ce6e5d5` | `fix(angular): multi-version support compliance (#35587)`                    |
+| `78f908d015` | `cleanup(angular): adopt shared version-floor helpers`                       |
+| `e2ef134645` | `fix(testing): multi-version support compliance for @nx/playwright (#35642)` |
+| `5d8b1bab7e` | `cleanup(devkit): allow excluding generators from version floor test helper` |
+| `bc35b484e3` | `fix(testing): multi-version support compliance for @nx/cypress (#35670)`    |
+
+Pre-squash branch SHAs are available via `gh pr view <N> --json commits` even after the branch is deleted; useful when inspecting one specific aspect of a merged PR in isolation. Example:
+
+```bash
+gh pr view 35642 --repo nrwl/nx --json commits | jq -r '.commits[] | "\(.oid[:10]) \(.messageHeadline)"'
+```
+
+## Shared helpers — current locations
+
+| File                                                                                | Exports                                                                                                                    |
+| ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| `packages/devkit/src/utils/version-floor.ts`                                        | `throwForUnsupportedVersion` (internal-only), `assertSupportedPackageVersion`                                              |
+| `packages/devkit/src/utils/installed-version.ts`                                    | `getInstalledPackageVersion`, `getDeclaredPackageVersion`, `isNonSemverDistTag`, `normalizeSemver`, `NON_SEMVER_DIST_TAGS` |
+| `packages/devkit/internal.ts`                                                       | re-exports from above (this is `@nx/devkit/internal`)                                                                      |
+| `packages/nx/src/internal-testing-utils/assert-generators-enforce-version-floor.ts` | `assertGeneratorsEnforceVersionFloor`                                                                                      |
+| `packages/devkit/internal-testing-utils.ts`                                         | re-exports `assertGeneratorsEnforceVersionFloor` (this is `@nx/devkit/internal-testing-utils`)                             |
+
+## Per-plugin compliant files (grep for the pattern)
+
+### `@nx/angular` (most extensive — has the `supportedVersions` list pattern)
+
+- `packages/angular/src/utils/assert-supported-angular-version.ts` — wrapper using `Math.min(...supportedVersions)`
+- `packages/angular/src/utils/assert-supported-angular-version.spec.ts` — the canonical 5-case spec
+- `packages/angular/src/utils/all-generators-enforce-floor.spec.ts` — the parameterized floor spec
+- `packages/angular/src/generators/add-linting/lib/add-angular-eslint-dependencies.ts` — `keepExistingVersions: true` pattern
+- `packages/angular/migrations.json` — MF `requires` gates and the over-gate removal
+
+### `@nx/playwright` (the helpers were generalized here)
+
+- `packages/playwright/src/utils/assert-supported-playwright-version.ts` — wrapper using a `minSupportedPlaywrightVersion` constant
+- `packages/playwright/src/utils/all-generators-enforce-floor.spec.ts`
+- `packages/playwright/src/utils/preset.ts` — runtime feature gating (blob reporter)
+- `packages/playwright/src/executors/merge-reports/merge-reports.impl.ts` — executor feature gating
+- `packages/playwright/src/utils/versions.ts` — `minSupportedPlaywrightVersion`, `minPlaywrightVersionForBlobReports`, `playwrightVersion = '^1.37.0'` (fresh install higher than peer)
+- `packages/playwright/src/utils/add-linter.ts` — `keepExistingVersions: true` in linter helper
+- `packages/playwright/package.json` — peer `^1.36.0` (unchanged), added `"semver": "catalog:"`
+
+### `@nx/cypress` (excludeGenerators + versions() rewrite)
+
+- `packages/cypress/src/utils/assert-supported-cypress-version.ts`
+- `packages/cypress/src/utils/all-generators-enforce-floor.spec.ts` — uses `excludeGenerators: ['migrate-to-cypress-11']` with code comment
+- `packages/cypress/src/utils/versions.ts` — `versions()` rewritten to `versionMap[major] ?? latestVersions`; `getInstalledCypressVersion` FS-path migrated to shared helper, tree-path kept inline
+
+## Finding current work-in-progress
+
+To enumerate all compliance PRs (merged + open) without relying on out-of-tree tracking docs:
+
+```bash
+# Open + merged compliance PRs
+gh pr list --repo nrwl/nx --search "multi-version compliance" --state all --limit 30 \
+  --json number,title,state,headRefName,author
+
+# Just open ones
+gh pr list --repo nrwl/nx --search "multi-version compliance" --state open
+```
+
+This is the authoritative list. Plugins covered to date can be derived by inspecting which packages each merged PR touched.
+
+To check which plugins still have known anti-patterns (e.g., phantom peer claims, missing floor assert), grep on master:
+
+```bash
+# Plugins WITHOUT an assert-supported-<pkg>-version wrapper
+for d in packages/*/src/utils; do
+  pkg=$(dirname "$d" | xargs basename)
+  if [ ! -f "$d/assert-supported-$pkg-version.ts" ] && \
+     [ ! -f "$d/assert-supported-${pkg/_/-}-version.ts" ]; then
+    echo "$pkg: no assert-supported wrapper"
+  fi
+done
+
+# Plugins missing the parameterized floor spec
+find packages -name "all-generators-enforce-floor.spec.ts" -not -path "*/dist/*"
+```
+
+Cross-reference with the third-party packages each plugin manages (peer deps in `package.json`).
+
+## How to use these examples
+
+When auditing a new plugin, before writing anything:
+
+1. Read the PR body of `#35642` (`@nx/playwright`) — it's the most comprehensive description of the canonical shape.
+2. Read the four files from `@nx/playwright`: `versions.ts`, `assert-supported-playwright-version.ts`, `all-generators-enforce-floor.spec.ts`, and `preset.ts`. Five minutes.
+3. If your plugin has a `migrations.json` of any complexity, also read `packages/angular/migrations.json` MF entries and the `update-unit-test-runner-option` entry for the gate patterns.
+4. If the plugin has runtime feature gates, also read `packages/playwright/src/executors/merge-reports/merge-reports.impl.ts`.
+
+When reviewing a compliance PR, the diff should look very similar to one of these reference PRs. Differences should be justifiable by the plugin's specifics (different floor, different feature gates, different migration shape) — not by departing from the canonical patterns.

.claude/skills/multi-version-compliance/references/gotchas.md

@@ -0,0 +1,241 @@
+# Gotchas & edge cases
+
+Non-obvious behavior. Load these into your model before auditing or reviewing.
+
+## `latest` / `next` dist-tags
+
+When a workspace declares `"<pkg>": "latest"` or `"next"` in its `package.json`:
+
+- `assertSupportedPackageVersion` no-ops via `isNonSemverDistTag` (NON_SEMVER_DIST_TAGS = `['latest', 'next']`). The floor check is skipped entirely.
+- `getDeclaredPackageVersion` falls back to the cleaned `latestKnownVersion` argument (if provided) or returns `null`.
+- `versions(tree)` returns `latestVersions` (the fresh-install path).
+
+Tests must include `latest` and `next` cases. Both are no-ops; neither throws.
+
+## pnpm `catalog:` references
+
+Declared versions may be `"catalog:default"`, `"catalog:typescript"`, etc. (since pnpm 9.5):
+
+- `getDependencyVersionFromPackageJson` (via the catalog manager in devkit) resolves these before the helper sees them. Don't call `clean`/`coerce` on raw values.
+- `normalizeSemver` behavior on a raw `catalog:` string is not explicitly tested (open question — verify if you encounter it).
+
+Reference: PR `#35459` (`fix(misc): resolve pnpm catalog: refs in version lookups`) — landed catalog ref handling.
+
+## Fresh-install path (package not declared)
+
+When `<pkg>` is missing from the workspace's `package.json` entirely:
+
+- `assertSupportedPackageVersion` no-ops.
+- `versions(tree)` returns `latestVersions`.
+- The generator proceeds with the fresh-install constant (e.g., `playwrightVersion = '^1.37.0'`).
+
+This is intentional — the generator is being run on a new workspace or one that's adding this package for the first time.
+
+## Error message preserves declared range, not cleaned semver
+
+```
+  Installed: ~18.2.0
+  Supported: >= 19.0.0
+```
+
+`Installed:` shows what's in `package.json` verbatim. Don't try to normalize it in the error message — it tells the user exactly what they typed, which helps them find it.
+
+The argument flow: `assertSupportedPackageVersion` calls `throwForUnsupportedVersion(packageName, declared, minSupportedVersion)` with the raw `declared` value.
+
+## Cypress's `getCypressVersionFromTree` stays inline
+
+The shared `getDeclaredPackageVersion` falls back to `latestKnownVersion` when the declared value is `latest`/`next` or missing. Cypress's tree path returns `null` on missing. These semantics differ enough that the helper can't be consolidated without changing behavior.
+
+The FS path (`getCypressVersionFromFileSystem`) was migrated to `getInstalledPackageVersion` (better resolution for pnpm strict / nested installs). The tree path stayed inline.
+
+Reference: `packages/cypress/src/utils/versions.ts` after `#35670`.
+
+## Double-asserts are fine
+
+When `configurationInternal` calls `initInternal` (or any generator chain), both call their respective `assertSupportedXVersion(tree)`. The assert is idempotent and cheap (one tree read + one semver comparison). Don't refactor away.
+
+The `assertGeneratorsEnforceVersionFloor` test treats both entry points as separate generators and asserts each throws — which is what we want.
+
+## Angular ecosystem lockstep — what `@angular/core >=N` covers
+
+Peer-locked to `@angular/core` (one `requires` on the primary is sufficient):
+
+- `@angular/cli`
+- `@angular/ssr`
+- `@angular-devkit/build-angular` **from v20+** (NOT v19 — `@angular-devkit/build-angular@19` does not peer-on `@angular/core`)
+- `@angular/material`, `@angular/cdk`, all `@angular/*` framework packages
+- `@schematics/angular`
+
+Independent (need their own `requires`):
+
+- `@ngrx/*`
+- `@angular-eslint/*`
+- `zone.js`
+- `jest-preset-angular`
+- `karma`, `karma-*`
+- `protractor` (deprecated)
+- `tailwindcss` and CSS-tooling siblings
+
+Always verify pairing at the actual version range being bumped from — `@angular-devkit/build-angular` is the classic gotcha (peers on `@angular/core` in some versions, not others).
+
+## Pruned migrations leave no trace in `migrations.json`
+
+Older `packageJsonUpdates` entries (e.g., `12.x` migrations) are removed during normal Nx version cleanup waves. They don't show up in the current `migrations.json` but their absence is meaningful — users on an old floor have no auto-bump path to the new floor.
+
+Check via:
+
+```sh
+git log --all --oneline -p -- packages/<plugin>/migrations.json | head -200
+git log --all --diff-filter=D --name-only -- packages/<plugin>/migrations.json
+```
+
+When raising a floor by N+ majors, decide whether to:
+
+1. Add a `packageJsonUpdates` entry bridging sub-floor → floor (the user gets auto-bumped on `nx migrate`).
+2. Leave the gap (the user sees the floor-assert error and has to bump manually).
+
+The Cypress v12 → v13 gap was left intentionally — users get the assert error and bump manually. Don't add a bridge entry without explicit agreement.
+
+## Pre-floor `packageJsonUpdates` entries are intentionally retained
+
+Distinct from the pruned-history case above: a plugin may carry `packageJsonUpdates` entries targeting source majors **below** the current support floor. Example: `@nx/react-native`'s entries `20.3.0` and `21.4.0` target RN versions below the current ~0.79.3 floor. These are intentionally retained for users on older Nx versions that supported older RN.
+
+Don't _add_ a bridge entry without explicit decision. Don't _remove_ a legitimately-pre-floor entry as part of a compliance pass. The W1/W4 audit window only covers entries that target source majors **inside** the current support window.
+
+## `subFloorVersion` must satisfy `lt(clean(it), floor)`
+
+For the parameterized floor spec, pick a value that's actually below the floor after `clean()`. Examples:
+
+| Floor    | Valid `subFloorVersion`        | Invalid                                                                                                                          |
+| -------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
+| `19.0.0` | `~18.2.0`, `^18.0.0`, `18.2.0` | `~19.0.0-beta.0` (clean strips the pre-release; in some cases this still satisfies `lt`, but it's confusing — avoid pre-release) |
+| `13.0.0` | `~12.17.0`, `^12.0.0`          | `^13.0.0-rc.0`                                                                                                                   |
+| `1.36.0` | `~1.35.0`, `^1.35.0`           | `1.36.0-beta.5`                                                                                                                  |
+
+Use a stable minor-or-patch range below floor. Don't use pre-release identifiers.
+
+## Declared floor vs. effective floor
+
+The declared floor (peer dep + `minSupported<Pkg>Version` + `versionMap` lowest entry) is what the plugin advertises. The **effective floor** is the lowest major where every third-party API the plugin's code actually calls is available. When they diverge, the declared floor is lying.
+
+How this happens: someone bumps the plugin to use a new API (e.g., `getRelevantTestSpecifications` introduced in vitest v3) without raising the floor. The plugin compiles, generators pass tests against the latest install lane, but workspaces on sub-effective-floor versions crash at runtime with `... is not a function`.
+
+How to detect: in the audit's runtime/executor inventory step, every `import` / `require` from the third-party package goes into a list. Cross-reference each named export against the third-party's release notes / API docs. The effective floor is the highest "introduced in" version across that list.
+
+How to fix: raise the declared floor to match the effective floor. Drop the now-unsupported entries from `versionMap`, peer, and any per-major aliases. The parameterized floor spec's `subFloorVersion` shifts up accordingly.
+
+Reference: open PR `#35671` (`@nx/vitest`) — proposed v2 floor initially; raised to v3 in a follow-up commit after spotting `getRelevantTestSpecifications` usage. See `anti-patterns.md` §16.
+
+## `versions()` fall-through above ceiling, not throw
+
+Before `#35670`, cypress's `versions()` had a `switch + throw default:`. This is wrong for two reasons:
+
+1. New majors that don't yet have a `versionMap` entry should silently use `latestVersions` — the plugin hasn't been updated to know about them, but the user should still be able to use them.
+2. Below-floor is already caught by the generator-level assert. The `versions()` throw is redundant for the in-range/sub-floor case, and wrong for the above-ceiling case.
+
+The pattern is always:
+
+```ts
+return versionMap[major as CompatVersions] ?? latestVersions;
+```
+
+## Tier-1 chaining in `packageJsonUpdates`
+
+Within a single `packageJsonUpdates` entry (single block), if entry A bumps package X and entry B has `requires: { X: ">=N" }` that depends on the post-bump value of X, B's gate evaluates against the post-bump state. This is **deliberate design**, not a bug.
+
+Concrete example: Storybook's `21.2.0-migrate-storybook-v9` migration is gated on `storybook >=9.0.0` even though the prior state was v8 — the sibling `packageJsonUpdates` `21.1.0` bumps Storybook to v9 first, so the v9 gate evaluates against post-bump state.
+
+This means you can have one block bump X then chain a sibling bump gated on X's new version, without splitting into separate `packageJsonUpdates` keys.
+
+## Cross-plugin coordination of shared third-party windows
+
+Some third-party packages are managed by multiple Nx plugins. Concrete example:
+
+- `@nx/cypress` pins `vite` v5 (for cypress v13) and v6 (for cypress v14+).
+- `@nx/vite` supports `vite` v5–v8.
+
+If `@nx/vite` drops v5 from its supported window, `@nx/cypress`'s v5 pin becomes an orphaned install lane — workspaces using both plugins are now in conflict.
+
+When raising / lowering a third-party's support window in one plugin, check every other plugin that manages the same package. The Linear milestone tasks call this out per-plugin (e.g., NXC-4384 cypress flags vite coordination with NXC-4407 vite).
+
+### Sibling declaration consistency
+
+When the same third-party package appears in multiple plugins, the declaration _kind_ (peerDependencies vs dependencies vs devDependencies) should be consistent unless the plugins genuinely have different roles for the package. Concrete inconsistency on master at time of writing: `@module-federation/enhanced ^2.3.3` is in `dependencies` in `@nx/module-federation` but `peerDependencies` in `@nx/rspack`. Pick one rule per package across the plugin family and document the exception when one plugin must differ.
+
+## Plugin must own its primary third-party's pin
+
+A plugin's install constants for its primary third-party must live in the plugin's own `packages/<plugin>/src/utils/versions.ts` — not in another plugin. Cross-plugin imports of install constants create governance drift (the owning plugin can't change the pin without breaking the borrower).
+
+Example anti-pattern: `@nx/esbuild`'s `esbuild` install constant living in `@nx/js`. Flagged in NXC-4386.
+
+## Schema-level deprecated-option stubs with runtime throws
+
+Established Angular pattern (also called out in NXC-4391 jest, NXC-4395 next, NXC-4408 vitest): when an option is deprecated/removed in a newer third-party major but the plugin still supports an older major where it's valid, **retain the option in the schema with a description-notice and throw at runtime when inapplicable to the installed major**.
+
+This keeps the schema accepting the union of options across the support window. Runtime branches on installed version and throws a clear message if the user passes an option that's only valid on a major they're not running.
+
+Reference: search the angular generators for `removed in Angular vN` style schema descriptions paired with `assertSupportedAngularVersion`-aware option handling.
+
+## Known-incomplete plugins
+
+These were touched by a compliance PR but the work is incomplete. Useful for review and for future PRs.
+
+- **`@nx/angular` init `keepExistingVersions`**: `packages/angular/src/generators/init/schema.json` has `default: false` and `packages/angular/src/generators/init/init.ts` passes `options.keepExistingVersions` directly (no `?? true`). PR `#35587` fixed `add-linting` but NOT the init generator. Flag in non-angular PRs as a reference to the pattern; fix in passing in any future angular PR. (Verify state on current master before citing.)
+- **`@nx/jest` peer-dep block missing entirely.** When adopting the floor assert, add `peerDependencies` first declaring `jest` / `ts-jest` / `@types/jest` ranges. Without the peer block, `getDependencyVersionFromPackageJson` for `jest` may return `undefined` on installed workspaces because pnpm catalog refs and certain other patterns rely on the peer being declared.
+- **Cypress v12→v13 migration gap**: when `#35670` raised the floor to v13, prior v12-cleanup `packageJsonUpdates` entries were already pruned. Decision was to leave it — v12 workspaces see the assert error and bump manually. Reference for the "raise floor, no bridge" pattern.
+- **`getInstalled<Pkg>Version` consolidation deferred**: each plugin still has its own near-identical helper (the FS-side has been migrated to the shared helper in some plugins, but a full unification across cypress/playwright/vitest/next/expo/angular is pending). Don't bundle that refactor into a compliance PR.
+
+## `migrate-to-cypress-11` and other intentional sub-floor migrators
+
+A generator whose purpose is to lift sub-floor workspaces onto a supported version must run on sub-floor workspaces. If it had the floor assert, it could never run.
+
+For these generators:
+
+- Do NOT add `assertSupportedXVersion(tree)` to them.
+- Keep their existing version checks (e.g., `assertMinimumCypressVersion(8)` in `migrate-to-cypress-11`).
+- Add them to `excludeGenerators` in `all-generators-enforce-floor.spec.ts` with a code comment explaining why.
+
+There are usually 0 or 1 of these per plugin. Greater than 1 is suspicious — review carefully.
+
+## `getInstalledPackageVersion` vs. `require('<pkg>/package.json')`
+
+Bare `require('<pkg>/package.json')` resolves from the plugin's own install location, which in pnpm strict mode or nested installs may not match the workspace's resolved version. `readModulePackageJson` (used by `getInstalledPackageVersion`) goes through `getNxRequirePaths()` for correct workspace-rooted resolution.
+
+Anywhere you read an installed version at runtime: prefer `getInstalledPackageVersion('<pkg>')`. Don't `require('<pkg>/package.json')`.
+
+## "Above ceiling" is NOT in the task spec
+
+Repeating because this gets re-introduced: above-ceiling handling is explicitly out of scope for these compliance tasks. If you find yourself adding it, you've drifted from the spec.
+
+The behavior we want above the highest known major: silent fall-through to `latestVersions`. The plugin will be updated to add a `versionMap` entry for the new major in a future PR. Until then, the user gets the latest install constants and may run into incompatibilities, which is the existing pre-compliance behavior. We are NOT trying to detect future majors and warn — that's a different feature.
+
+## Decisions you cannot make alone
+
+Pause and ask when:
+
+- **Peer-range drop:** dropping a major from the peer might be a regression if tests pass on that version. Verify whether the absence of an install lane reflects "we never supported it" (legitimate drop) or "we shipped support and quietly broke it" (regression — investigate before dropping).
+- **Floor raise without a bridging migration:** raising the floor by N+ majors means users on the lowest sub-floor major see the assert error and must manually bump. Confirm with the user: acceptable, or add a `packageJsonUpdates` bridge?
+- **`requires` removal on a borderline migration:** the diff says the migration is Nx-only (no third-party config touched), but it reads a config file that only exists at certain third-party versions. The third-party dependency is indirect but real. Don't remove the gate without verifying.
+- **Peer floor and fresh-install constant diverge** (playwright pattern — peer `^1.36.0`, fresh-install `^1.37.0`). Confirm the gap is justified by feature surface (1.37 introduced the blob reporter + merge-reports CLI) and not an oversight.
+- **Ecosystem-locked vs. independent sibling classification:** before adding or removing a sibling's `requires` entry, read its `peerDependencies` block at the version range being bumped from. `@angular-devkit/build-angular` is the gotcha — only peer-locked to `@angular/core` from v20+.
+- **Pruned migration gap:** the lowest sub-floor major has no auto-bump path because prior `packageJsonUpdates` entries were removed during cleanup waves. Decide: add a bridge entry, or accept the manual bump? `git log --diff-filter=D -- packages/<plugin>/migrations.json` reveals the gap.
+- **New plugin doesn't fit the canonical shape** (manages multiple primary packages with different floors, runs partially as a Nx-internal-only plugin, etc.). Ask before improvising — see `canonical-shape.md` §"Plugins managing multiple primary packages" for the established multi-primary pattern.
+- **Test fails on `latest`/`next` despite the assert being a no-op.** The no-op behavior is intentional, but if the generator downstream of the assert can't handle the unresolved range, that's a real bug — not something to paper over by tightening the assert.
+
+## Per-plugin decision log
+
+These were decided once for the reference PRs (#35587, #35642, #35670) — apply them as defaults unless explicitly contradicted by the user for a new plugin:
+
+- **Executors do NOT enforce the plugin floor.** Generator-only. Executors gate per-feature, not per-floor.
+- **Above-ceiling: silent fall-through to `latestVersions`.** No warn, no throw, no branch.
+- **Init generators preserve user pins** via `keepExistingVersions: true` (schema default) and the `?? true` safety net at the call site.
+- **Skip writing the install constant when the package is already detected** (cypress + angular pattern — preserves the user's installed minor/patch).
+- **Shared helpers stay in `@nx/devkit/internal`** — not part of the public devkit surface. (The W2 ticket originally proposed adding `throwForUnsupportedVersion` to the public devkit API; the implementation landed under `/internal` instead, matching how other version-related helpers ship.)
+- **Consolidation of per-plugin `getInstalled<Pkg>Version` helpers is deferred** — don't bundle that refactor into a compliance PR.
+
+Plugin-specific decisions that may be pending or have settled differently (check the live PR state via `gh pr list --repo nrwl/nx --search "multi-version compliance"`):
+
+- `@nx/jest` — needs a `peerDependencies` block for `jest`/`ts-jest`/`@types/jest` before the floor assert can rely on `getDependencyVersionFromPackageJson`.
+- `@nx/eslint` — historically gated on an ESLint v8 EOL decision. If you're touching it, confirm the decision is settled.
+- `@nx/eslint-plugin` — historically coupled to the eslint v8 decision (typescript-eslint v6/v7 only support eslint v8). Confirm before proceeding.
+- `@nx/rspack` / `@nx/rsbuild` — there is an open PR (`#35676` at time of writing). Inspect for the local-helper-duplication anti-pattern (`anti-patterns.md` §1).

.claude/skills/nx-docs-style-check/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: nx-docs-style-check
+description: Check modified Nx documentation pages against the astro-docs style guide. Auto-trigger after writing or editing docs content in the nx repo. Also trigger on "check style", "style guide", "docs review", "validate docs". Should run as a final step whenever docs files are modified. IMPORTANT: anytime astro-docs/**/*.mdoc files are modified, this should always run automatically without being asked.
+allowed-tools: Read, Glob, Grep
+---
+
+# Nx docs style check
+
+You are a documentation editor for Nx. Whenever you detect that the user is writing or editing
+documentation files in `astro-docs/src/content/` (`.mdoc`, `.mdx`, `.md`), automatically run this
+check and fix any issues. Do not wait to be asked.
+
+## Phase 1: Information architecture audit
+
+Read `astro-docs/STYLE_GUIDE.md` (the "Information architecture" section) and
+`astro-docs/sidebar.mts` to understand where the page lives in the sidebar hierarchy.
+
+For every new or moved page, evaluate against ALL FIVE principles. These are non-negotiable:
+
+### 1. Progressive disclosure ("journey" rule)
+
+- Is this for the first 30 minutes (Getting Started), first 30 days (Features), or forever (Reference)?
+- Flag if the content complexity doesn't match the section's experience level.
+
+### 2. Category homogeneity ("scan" rule)
+
+- Look at sibling pages in the same sidebar section.
+- Do they all share the same content type (concepts, tasks, or products)?
+- Flag if this page mixes types that siblings don't.
+
+### 3. Type-based navigation ("intent" rule)
+
+- Is this a learning page (narrative/guide) or a lookup page (reference/API)?
+- Flag if it's in the wrong category (e.g., a reference page in a guides section).
+
+### 4. Pen and paper test ("theory" rule)
+
+- Can the page be explained using only pen and paper (no terminal needed)?
+- YES = belongs in "How Nx Works" (architecture/concepts)
+- NO (needs terminal/code examples) = belongs in "Platform Features" or "Technologies"
+- Flag if a concept page has terminal output, CLI commands, or code-heavy examples.
+
+### 5. Universal vs. specific ("placement" rule)
+
+- Does this feature apply to every Nx user?
+- YES = "Platform Features"
+- NO (only React/Angular/etc. users) = "Technologies"
+- Flag if a technology-specific page is in Platform Features or vice versa.
+
+## Phase 2: Style validation
+
+### Step 1: Run Vale and fix errors
+
+Run `nx run astro-docs:vale` to check the modified files.
+
+- **errors** — fix these automatically. Edit the file to resolve the violation.
+- **warnings** — fix these automatically when the fix is unambiguous (e.g., sentence case headings).
+  For ambiguous cases, suggest the fix and ask.
+- **suggestions** — mention them to the user but do not auto-fix.
+
+### Step 2: Fix issues Vale doesn't catch
+
+Read `astro-docs/STYLE_GUIDE.md` and check for that things that Vale may have missed.
+
+### Handling false positives
+
+Use inline Vale comments to suppress legitimate exceptions:
+
+```markdown
+<!-- vale Nx.Headings = NO -->
+
+## extractLicenses
+
+<!-- vale Nx.Headings = YES -->
+```
+
+Common cases where suppression is appropriate:
+
+- **CLI option headings** (e.g., `## extractLicenses`) — camelCase by design.
+  Prefer wrapping in backticks first (`## \`extractLicenses\``).
+- **Product possessives in historical/migration context** (e.g., "Angular's original schematic system")
+- **Terminology in migration docs** (e.g., explaining what "schematics" were before being renamed)
+
+Do NOT suppress rules just to avoid fixing real violations.
+
+## Output summary
+
+After fixing, report what you did:
+
+```
+## Style check results
+
+### Information architecture: [PASS/FAIL]
+[List any violations or confirm all five principles pass]
+
+### Vale: [X errors fixed, Y warnings fixed, Z suggestions noted]
+[Summary of changes made]
+
+### Manual fixes: [list of additional fixes applied]
+```

.claude/skills/nx-gradle-plugin-version-bump/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: nx-gradle-plugin-version-bump
+description: Bump the dev.nx.gradle.project-graph plugin version. Use when updating the Gradle project graph plugin version across the codebase, creating the migration files, and updating migrations.json.
+allowed-tools: Bash, Read, Write, Edit, Glob, Grep
+---
+
+# Gradle Plugin Version Bump
+
+Bumps the `dev.nx.gradle.project-graph` plugin to a new version. This is a recurring task that touches 5 files in an identical pattern every time.
+
+## Required Inputs
+
+Collect these values from the master branch before starting:
+
+1. `NEW_VERSION` - the version we want to bump to
+   Example: OLD_VERSION: 0.1.15 => NEW_VERSION: 0.1.16
+   You can find this value by looking at the `OLD_VERSION` specified in `packages/gradle/project-graph/build.gradle.kts` in the `version` field.  
+   The NEW_VERSION will be the `OLD_VERSION` + 1.
+
+2. `NX_MIGRATION_VERSION` - the version of Nx that will trigger our version bump migration
+   Example: OLD_VERSION: 22.7.0-beta.0 => NEW_VERSION: 22.7.0-beta.1
+   You can find this value by looking at the `nx` version in `package.json` under `devDependencies`. The NEW_VERSION will be the `OLD_VERSION` + 1.
+
+3. `MIGRATION_FOLDER` - the folder name under `packages/gradle/src/migrations/` that will contain our migration files
+   Example: NEW_VERSION: 22.7.0-beta.1 => MIGRATION_FOLDER: 22-7-0
+   Take the version and replace all the dots with hyphens and remove the `beta` or `rc` suffix.
+
+## Steps
+
+### 1. Update the version constant
+
+**File:** `packages/gradle/src/utils/versions.ts`
+
+Change `gradleProjectGraphVersion` to the new version:
+
+```ts
+export const gradleProjectGraphVersion = 'NEW_VERSION';
+```
+
+### 2. Update build.gradle.kts
+
+**File:** `packages/gradle/project-graph/build.gradle.kts`
+
+Update the `version` on line 13:
+
+```kotlin
+version = "NEW_VERSION"
+```
+
+### 3. Create migration TypeScript file
+
+**File:** `packages/gradle/src/migrations/MIGRATION_FOLDER/change-plugin-version-NEW_VERSION.ts`
+
+Determine the previous version by reading the current `gradleProjectGraphVersion` from `packages/gradle/src/utils/versions.ts` before modifying it.
+
+Template:
+
+```ts
+import { Tree, readNxJson } from '@nx/devkit';
+import { hasGradlePlugin } from '../../utils/has-gradle-plugin';
+import { addNxProjectGraphPlugin } from '../../generators/init/gradle-project-graph-plugin-utils';
+import { updateNxPluginVersionInCatalogsAst } from '../../utils/version-catalog-ast-utils';
+
+/* Change the plugin version to NEW_VERSION
+ */
+export default async function update(tree: Tree) {
+  const nxJson = readNxJson(tree);
+  if (!nxJson) {
+    return;
+  }
+  if (!hasGradlePlugin(tree)) {
+    return;
+  }
+
+  const gradlePluginVersionToUpdate = 'NEW_VERSION';
+
+  // Update version in version catalogs using AST-based approach to preserve formatting
+  await updateNxPluginVersionInCatalogsAst(tree, gradlePluginVersionToUpdate);
+
+  // Then update in build.gradle(.kts) files
+  await addNxProjectGraphPlugin(tree, gradlePluginVersionToUpdate);
+}
+```
+
+### 4. Create migration documentation file
+
+**File:** `packages/gradle/src/migrations/MIGRATION_FOLDER/change-plugin-version-NEW_VERSION.md`
+
+Replace `PREV_VERSION` with the version that was current before this bump.
+
+Template:
+
+````md
+#### Change dev.nx.gradle.project-graph to version NEW_VERSION
+
+Change dev.nx.gradle.project-graph to version NEW_VERSION in build file
+
+#### Sample Code Changes
+
+##### Before
+
+\```text title="build.gradle"
+plugins {
+id "dev.nx.gradle.project-graph" version "PREV_VERSION"
+}
+\```
+
+##### After
+
+\```text title="build.gradle"
+plugins {
+id "dev.nx.gradle.project-graph" version "NEW_VERSION"
+}
+\```
+````
+
+### 5. Add migration entry to migrations.json
+
+**File:** `packages/gradle/migrations.json`
+
+Add a new entry at the end of the `generators` object (before the closing `}`), following the existing pattern:
+
+```json
+"change-plugin-version-NEW_VERSION": {
+  "version": "NX_MIGRATION_VERSION",
+  "cli": "nx",
+  "description": "Change dev.nx.gradle.project-graph to version NEW_VERSION in build file",
+  "factory": "./src/migrations/MIGRATION_FOLDER/change-plugin-version-NEW_VERSION"
+}
+```
+
+The migration key uses the version with hyphens replacing dots (e.g., `0-1-16`).
+
+## Verification
+
+Run:
+
+```bash
+nx run-many -t test,build,lint -p gradle
+```
+
+## Commit Convention
+
+```
+chore(gradle): bump gradle project graph plugin version to NEW_VERSION
+```
+
+## Final Verification
+
+Take a look at the most recent Gradle version bump PR and compare your changes to that. You should not be touching more or less files than
+the most recent version bump PR. If you do, ask for more information and stop all changes.

.claude/skills/run-nx-generator/SKILL.md

@@ -67,15 +67,6 @@ nx generate @nx/workspace-plugin:bump-maven-version \
 
 This automates all the version bumping instead of manual file edits.
 
-### Creating a New Plugin
-
-For creating a new create-nodes plugin:
-
-```bash
-nx generate @nx/workspace-plugin:create-nodes-plugin \
-  --name my-custom-plugin
-```
-
 ## When to Use This Skill
 
 Use this skill when you need to:

.cursor/agents/ci-watcher.md

@@ -0,0 +1,480 @@
+---
+name: ci-watcher
+description: Polls Nx Cloud CI pipeline and self-healing status. Returns structured state when actionable. Spawned by /nx-cloud-ci-monitor command to monitor CI Attempt status.
+model: fast
+---
+
+# CI Watcher Subagent
+
+You are a CI monitoring subagent responsible for polling Nx Cloud CI Attempt status and self-healing state. You report status back to the main agent - you do NOT make apply/reject decisions.
+
+## Your Responsibilities
+
+1. Poll CI status using the `ci_information` MCP tool
+2. Implement exponential backoff between polls
+3. Return structured state when an actionable condition is reached
+4. Track iteration count and elapsed time
+5. Output status updates based on verbosity level
+
+## Input Parameters (from Main Agent)
+
+The main agent may provide these optional parameters in the prompt:
+
+| Parameter           | Description                                              |
+| ------------------- | -------------------------------------------------------- |
+| `branch`            | Branch to monitor (auto-detected if not provided)        |
+| `expectedCommitSha` | Commit SHA that should trigger a new CI Attempt          |
+| `previousCipeUrl`   | CI Attempt URL before the action (to detect change)      |
+| `subagentTimeout`   | Polling timeout in minutes (default: 60)                 |
+| `verbosity`         | Output level: minimal, medium, verbose (default: medium) |
+
+When `expectedCommitSha` or `previousCipeUrl` is provided, you must detect whether a new CI Attempt has spawned.
+
+## MCP Tool Reference
+
+### `ci_information`
+
+**Input:**
+
+```json
+{
+  "branch": "string (optional, defaults to current git branch)",
+  "select": "string (optional, comma-separated field names)",
+  "pageToken": "number (optional, 0-based pagination for long strings)"
+}
+```
+
+**Output:**
+
+```json
+{
+  "cipeStatus": "NOT_STARTED | IN_PROGRESS | SUCCEEDED | FAILED | CANCELED | TIMED_OUT",
+  "cipeUrl": "string",
+  "branch": "string",
+  "commitSha": "string | null",
+  "failedTaskIds": "string[]",
+  "verifiedTaskIds": "string[]",
+  "selfHealingEnabled": "boolean",
+  "selfHealingStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "verificationStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "userAction": "NONE | APPLIED | REJECTED | APPLIED_LOCALLY | APPLIED_AUTOMATICALLY | null",
+  "failureClassification": "string | null",
+  "taskOutputSummary": "string | null",
+  "suggestedFixReasoning": "string | null",
+  "suggestedFixDescription": "string | null",
+  "suggestedFix": "string | null",
+  "shortLink": "string | null",
+  "couldAutoApplyTasks": "boolean | null",
+  "confidence": "number | null",
+  "confidenceReasoning": "string | null"
+}
+```
+
+**Select Parameter:**
+
+| Usage           | Returns                                                     |
+| --------------- | ----------------------------------------------------------- |
+| No `select`     | Formatted overview (truncated, not recommended for polling) |
+| Single field    | Raw value with pagination for long strings                  |
+| Multiple fields | Object with requested field values                          |
+
+**Field Sets for Efficient Polling:**
+
+```yaml
+WAIT_FIELDS:
+  'cipeUrl,commitSha,cipeStatus'
+  # Minimal fields for detecting new CI Attempt
+
+LIGHT_FIELDS:
+  'cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning'
+  # Status fields for determining actionable state
+
+HEAVY_FIELDS:
+  'taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription'
+  # Large content fields - fetch only when returning to main agent
+```
+
+## Initial Wait
+
+Before first poll, wait based on context:
+
+- **Fresh start (no expected CIPE):** Wait 60 seconds to allow CI to start
+- **Expecting new CIPE:** Wait 30 seconds (action already triggered)
+
+**IMPORTANT:** Always run sleep in foreground, NOT as background command.
+
+```bash
+sleep 60  # or 30 if expecting new CIPE (FOREGROUND, not background)
+```
+
+## Two-Phase Operation
+
+The subagent operates in one of two modes depending on input:
+
+### Mode 1: Fresh Start (no `expectedCommitSha` or `previousCipeUrl`)
+
+Normal polling - process whatever CIPE is returned by `ci_information`.
+
+### Mode 2: Wait-for-New-CIPE (when `expectedCommitSha` or `previousCipeUrl` provided)
+
+**CRITICAL**: When expecting a new CIPE, the subagent must **completely ignore** the old/stale CIPE. Do NOT process its status, do NOT return actionable states based on it.
+
+#### Phase A: Wait Mode
+
+1. Start a **new-CIPE timeout** timer (default: 30 minutes)
+2. On each poll of `ci_information`:
+   - Check if CIPE is NEW:
+     - `cipeUrl` differs from `previousCipeUrl` → **new CIPE detected**
+     - `commitSha` matches `expectedCommitSha` → **correct CIPE detected**
+   - If still OLD CIPE: **ignore all status fields**, just wait and poll again
+   - Do NOT return `fix_available`, `ci_success`, etc. based on old CIPE!
+3. Output wait status (see below)
+4. If timeout (30 min) reached → return `no_new_cipe`
+
+#### Phase B: Normal Polling (after new CIPE detected)
+
+Once new CIPE is detected:
+
+1. Clear the new-CIPE timeout
+2. Switch to normal polling mode
+3. Process the NEW CIPE's status normally
+4. Return when actionable state reached
+
+### Wait Mode Output
+
+While in wait mode, output clearly that you're waiting (not processing):
+
+```
+[CI Monitor] ═══════════════════════════════════════════════════════
+[CI Monitor] WAIT MODE - Expecting new CI Attempt
+[CI Monitor] Expected SHA: <expectedCommitSha>
+[CI Monitor] Previous CI Attempt: <previousCipeUrl>
+[CI Monitor] ═══════════════════════════════════════════════════════
+
+[CI Monitor] Polling... (elapsed: 0m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 1m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 2m 30s)
+[CI Monitor] ✓ New CI Attempt detected! URL: <newCipeUrl>, SHA: <newCommitSha>
+[CI Monitor] Switching to normal polling mode...
+```
+
+### Why This Matters (Context Preservation)
+
+**The problem**: Stale CIPE data can be very large:
+
+- `taskOutputSummary`: potentially thousands of characters of build/test output
+- `suggestedFix`: entire patch files
+- `suggestedFixReasoning`: detailed explanation
+
+If subagent returns stale CIPE data to main agent, it **pollutes main agent's context** with useless information (we already processed that CIPE). This wastes valuable context window.
+
+**Without wait mode:**
+
+1. Poll `ci_information` → get old CIPE with huge data
+2. Return to main agent with all that stale data
+3. Main agent's context gets polluted with useless info
+4. Main agent has to process/ignore it anyway
+
+**With wait mode:**
+
+1. Poll `ci_information` → get old CIPE → **ignore it, don't return**
+2. Keep waiting internally (stale data stays in subagent)
+3. New CIPE appears → switch to normal mode
+4. Return to main agent with only the NEW, relevant CIPE data
+
+## Polling Loop
+
+### Subagent State Management
+
+Maintain internal accumulated state across polls:
+
+```
+accumulated_state = {}
+```
+
+### Call `ci_information` MCP Tool
+
+**Wait Mode (expecting new CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeUrl,commitSha,cipeStatus"
+})
+```
+
+Only fetch minimal fields needed to detect CI Attempt change. Do NOT fetch heavy fields - stale data wastes context.
+
+**Normal Mode (processing CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning"
+})
+```
+
+Merge response into `accumulated_state` after each poll.
+
+### Analyze Response
+
+**If in Wait Mode** (expecting new CIPE):
+
+1. Check if CIPE is new (see Two-Phase Operation above)
+2. If old CIPE → **ignore status**, output wait message, poll again
+3. If new CIPE → switch to normal mode, continue below
+
+**If in Normal Mode**:
+Based on the response, decide whether to **keep polling** or **return to main agent**.
+
+### Keep Polling When
+
+Continue polling (with backoff) if ANY of these conditions are true:
+
+| Condition                               | Reason                                   |
+| --------------------------------------- | ---------------------------------------- |
+| `cipeStatus == 'IN_PROGRESS'`           | CI still running                         |
+| `cipeStatus == 'NOT_STARTED'`           | CI hasn't started yet                    |
+| `selfHealingStatus == 'IN_PROGRESS'`    | Self-healing agent working               |
+| `selfHealingStatus == 'NOT_STARTED'`    | Self-healing not started yet             |
+| `failureClassification == 'FLAKY_TASK'` | Auto-rerun in progress                   |
+| `userAction == 'APPLIED_AUTOMATICALLY'` | New CI Attempt spawning after auto-apply |
+
+When `couldAutoApplyTasks == true`:
+
+- `verificationStatus` = `NOT_STARTED`, `IN_PROGRESS` → keep polling (verification still in progress)
+- `verificationStatus` = `COMPLETED` → return `fix_auto_applying` (auto-apply will happen, main agent spawns wait mode subagent)
+- `verificationStatus` = `FAILED`, `NOT_EXECUTABLE` → return `fix_available` (auto-apply won't happen, needs manual action)
+
+### Exponential Backoff
+
+Between polls, wait with exponential backoff:
+
+| Poll Attempt | Wait Time         |
+| ------------ | ----------------- |
+| 1st          | 60 seconds        |
+| 2nd          | 90 seconds        |
+| 3rd+         | 120 seconds (cap) |
+
+Reset to 60 seconds when state changes significantly.
+
+**IMPORTANT:** Run sleep in foreground (NOT as background command). Background sleep causes "What should Claude do?" prompts when completed.
+
+```bash
+# Example backoff - run in FOREGROUND
+sleep 60   # First wait
+sleep 90   # Second wait
+sleep 120  # Third and subsequent waits (capped)
+```
+
+### Fetch Heavy Fields on Actionable State
+
+Before returning to main agent, fetch heavy fields if the status requires them:
+
+| Status              | Heavy Fields Needed                                                            |
+| ------------------- | ------------------------------------------------------------------------------ |
+| `ci_success`        | None                                                                           |
+| `fix_auto_applying` | None                                                                           |
+| `fix_available`     | `taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription` |
+| `fix_failed`        | `taskOutputSummary`                                                            |
+| `no_fix`            | `taskOutputSummary`                                                            |
+| `environment_issue` | None                                                                           |
+| `no_new_cipe`       | None                                                                           |
+| `polling_timeout`   | None                                                                           |
+| `cipe_canceled`     | None                                                                           |
+| `cipe_timed_out`    | None                                                                           |
+
+```
+# Example: fetching heavy fields for fix_available
+ci_information({
+  branch: "<branch_name>",
+  select: "taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription"
+})
+```
+
+Merge response into `accumulated_state`, then return merged state to main agent.
+
+**Pagination:** Heavy string fields return first page only. If `hasMore` indicated, include in return format so main agent knows more content available.
+
+### Return to Main Agent When
+
+Return immediately with structured state if ANY of these conditions are true:
+
+| Status              | Condition                                                                                                                                                 |
+| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | `cipeStatus == 'SUCCEEDED'`                                                                                                                               |
+| `fix_auto_applying` | `selfHealingStatus == 'COMPLETED'` AND `couldAutoApplyTasks == true` AND `verificationStatus == 'COMPLETED'`                                              |
+| `fix_available`     | `selfHealingStatus == 'COMPLETED'` AND `suggestedFix != null` AND (`couldAutoApplyTasks != true` OR `verificationStatus` in (`FAILED`, `NOT_EXECUTABLE`)) |
+| `fix_failed`        | `selfHealingStatus == 'FAILED'`                                                                                                                           |
+| `environment_issue` | `failureClassification == 'ENVIRONMENT_STATE'`                                                                                                            |
+| `no_fix`            | `cipeStatus == 'FAILED'` AND (`selfHealingEnabled == false` OR `selfHealingStatus == 'NOT_EXECUTABLE'`)                                                   |
+| `no_new_cipe`       | `expectedCommitSha` or `previousCipeUrl` provided, but no new CI Attempt detected after 30 min                                                            |
+| `polling_timeout`   | Subagent has been polling for > configured timeout (default 60 min)                                                                                       |
+| `cipe_canceled`     | `cipeStatus == 'CANCELED'`                                                                                                                                |
+| `cipe_timed_out`    | `cipeStatus == 'TIMED_OUT'`                                                                                                                               |
+
+## Subagent Timeout
+
+Track elapsed time. If you have been polling for more than **60 minutes** (configurable via main agent), return with `status: polling_timeout`.
+
+## Return Format
+
+When returning to the main agent, provide a structured response with accumulated state:
+
+```
+## CI Monitor Result
+
+**Status:** <status>
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### CI Attempt Details
+- **Status:** <cipeStatus>
+- **URL:** <cipeUrl>
+- **Branch:** <branch>
+- **Commit:** <commitSha>
+- **Failed Tasks:** <failedTaskIds>
+- **Verified Tasks:** <verifiedTaskIds>
+
+### Self-Healing Details
+- **Enabled:** <selfHealingEnabled>
+- **Status:** <selfHealingStatus>
+- **Verification:** <verificationStatus>
+- **User Action:** <userAction>
+- **Classification:** <failureClassification>
+- **Confidence:** <confidence>
+- **Confidence Reasoning:** <confidenceReasoning>
+
+### Fix Information (if available)
+- **Short Link:** <shortLink>
+- **Description:** <suggestedFixDescription>
+- **Reasoning:** <suggestedFixReasoning>
+
+### Task Output Summary (first page)
+<taskOutputSummary>
+[MORE_CONTENT_AVAILABLE: taskOutputSummary, pageToken: 1]
+
+### Suggested Fix (first page)
+<suggestedFix>
+[MORE_CONTENT_AVAILABLE: suggestedFix, pageToken: 1]
+```
+
+### Pagination Indicators
+
+When a heavy field has more content available, append indicator:
+
+```
+[MORE_CONTENT_AVAILABLE: <fieldName>, pageToken: <nextPage>]
+```
+
+Main agent can fetch additional pages if needed using:
+
+```
+ci_information({ select: "<fieldName>", pageToken: <nextPage> })
+```
+
+Fields that may have pagination:
+
+- `taskOutputSummary` (reverse pagination - page 0 = most recent)
+- `suggestedFix` (forward pagination - page 0 = start)
+- `suggestedFixReasoning`
+
+### Return Format for `no_new_cipe`
+
+When returning with `status: no_new_cipe`, include additional context:
+
+```
+## CI Monitor Result
+
+**Status:** no_new_cipe
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### Expected CI Attempt Not Found
+- **Expected Commit SHA:** <expectedCommitSha>
+- **Previous CI Attempt URL:** <previousCipeUrl>
+- **Last Seen CI Attempt URL:** <cipeUrl>
+- **Last Seen Commit SHA:** <commitSha>
+- **New CI Attempt Timeout:** 30 minutes (exceeded)
+
+### Likely Cause
+CI workflow failed before Nx tasks could run (e.g., install step, checkout, auth).
+Check your CI provider logs for the commit <expectedCommitSha>.
+
+### Last Known CI Attempt State
+- **Status:** <cipeStatus>
+- **Branch:** <branch>
+```
+
+## Status Reporting (Verbosity-Controlled)
+
+Output is controlled by the `verbosity` parameter from the main agent:
+
+| Level     | What to Output                                                    |
+| --------- | ----------------------------------------------------------------- |
+| `minimal` | No intermediate output. Only return final result when actionable. |
+| `medium`  | Output only on significant state changes (not every poll).        |
+| `verbose` | Output detailed phase information after every poll.               |
+
+### Minimal Verbosity
+
+No output during polling. Poll silently and return when done.
+
+### Medium Verbosity (Default)
+
+Output **only when state changes significantly** to save context tokens:
+
+- `cipeStatus` changes (e.g., IN_PROGRESS → FAILED)
+- `selfHealingStatus` changes (e.g., IN_PROGRESS → COMPLETED)
+- New CI Attempt detected (in wait mode)
+
+Format: single line, no decorators:
+
+```
+[CI Monitor] CI: FAILED | Self-Healing: IN_PROGRESS | Elapsed: 4m
+```
+
+### Verbose Verbosity
+
+Output detailed phase box after every poll:
+
+```
+[CI Monitor] ─────────────────────────────────────────────────────
+[CI Monitor] Iteration <N> | Elapsed: <X>m <Y>s
+[CI Monitor]
+[CI Monitor] CI Status:          <cipeStatus>
+[CI Monitor] Self-Healing:       <selfHealingStatus>
+[CI Monitor] Verification:       <verificationStatus>
+[CI Monitor] Classification:     <failureClassification>
+[CI Monitor]
+[CI Monitor] → <human-readable phase description>
+[CI Monitor] ─────────────────────────────────────────────────────
+```
+
+### Phase Descriptions (for verbose output)
+
+| Status Combo                                                                              | Description                                 |
+| ----------------------------------------------------------------------------------------- | ------------------------------------------- |
+| `cipeStatus: IN_PROGRESS`                                                                 | "CI running..."                             |
+| `cipeStatus: NOT_STARTED`                                                                 | "Waiting for CI to start..."                |
+| `cipeStatus: FAILED` + `selfHealingStatus: NOT_STARTED`                                   | "CI failed. Self-healing starting..."       |
+| `cipeStatus: FAILED` + `selfHealingStatus: IN_PROGRESS`                                   | "CI failed. Self-healing generating fix..." |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: IN_PROGRESS` | "Fix generated! Verification running..."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: COMPLETED`   | "Fix ready! Verified successfully."         |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: FAILED`      | "Fix generated but verification failed."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: FAILED`                                        | "Self-healing could not generate a fix."    |
+| `cipeStatus: SUCCEEDED`                                                                   | "CI passed!"                                |
+
+## Important Notes
+
+- You do NOT make apply/reject decisions - that's the main agent's job
+- You do NOT perform git operations
+- You only poll and report state
+- Respect the `verbosity` parameter for output (default: medium)
+- If `ci_information` returns an error, wait and retry (count as failed poll)
+- Track consecutive failures - if 5 consecutive failures, return with `status: error`
+- When expecting new CI Attempt, track the 30-minute new-CI-Attempt timeout separately from the main polling timeout

.cursor/commands/ci-monitor.md

@@ -0,0 +1,428 @@
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.cursor/skills/ci-monitor/SKILL.md

@@ -0,0 +1,437 @@
+---
+name: ci-monitor
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+$ARGUMENTS
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `$ARGUMENTS` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.cursor/skills/nx-generate/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: nx-generate
+description: Generate code using nx generators. USE WHEN scaffolding code or transforming existing code - for example creating libraries or applications, or anything else that is boilerplate code or automates repetitive tasks. ALWAYS use this first when generating code with Nx instead of calling MCP tools or running nx generate immediately.
+---
+
+# Run Nx Generator
+
+Nx generators are powerful tools that scaffold projects, make automated code migrations or automate repetitive tasks in a monorepo. They ensure consistency across the codebase and reduce boilerplate work.
+
+This skill applies when the user wants to:
+
+- Create new projects like libraries or applications
+- Scaffold features or boilerplate code
+- Run workspace-specific or custom generators
+- Do anything else that an nx generator exists for
+
+## Generator Discovery Flow
+
+### Step 1: List Available Generators
+
+Use the Nx CLI to discover available generators:
+
+- List all generators for a plugin: `npx nx list @nx/react`
+- View available plugins: `npx nx list`
+
+This includes:
+
+- Plugin generators (e.g., `@nx/react:library`, `@nx/js:library`)
+- Local workspace generators (defined in the repo's own plugins)
+
+### Step 2: Match Generator to User Request
+
+Based on the user's request, identify which generator(s) could fulfill their needs. Consider:
+
+- What artifact type they want to create (library, application, etc.)
+- Which framework or technology stack is relevant
+- Whether they mentioned specific generator names
+
+**IMPORTANT**: When both a local workspace generator and an external plugin generator could satisfy the request, **always prefer the local workspace generator**. Local generators are customized for the specific repo's patterns and conventions.
+
+It's possible that the user request is something that no Nx generator exists for whatsoever. In this case, you can stop using this skill and try to help the user another way. HOWEVER, the burden of proof for this is high. Before aborting, carefully consider each and every generator that's available. Look into details for any that could be related in any way before making this decision.
+
+## Pre-Execution Checklist
+
+Before running any generator, complete these steps:
+
+### 1. Fetch Generator Schema
+
+Use the `--help` flag to understand all available options:
+
+```bash
+npx nx g @nx/react:library --help
+```
+
+Pay attention to:
+
+- Required options that must be provided
+- Optional options that may be relevant to the user's request
+- Default values that might need to be overridden
+
+### 2. Read Generator Source Code
+
+Understanding what the generator actually does helps you:
+
+- Know what files will be created/modified
+- Understand any side effects (updating configs, installing deps, etc.)
+- Identify options that might not be obvious from the schema
+
+To find generator source code:
+
+- For plugin generators: Use `node -e "console.log(require.resolve('@nx/<plugin>/generators.json'));"` to find the generators.json, then locate the source from there
+- If that fails, read directly from `node_modules/<plugin>/generators.json`
+- For local generators: They are typically in `tools/generators/` or a local plugin directory. You can search the repo for the generator name to find it.
+
+### 2.5 Reevaluate if the generator is right
+
+Once you have built up an understanding of what the selected generator does, reconsider: Is this the right generator to service the user request?
+If not, it's okay to go back to the Generator Discovery Flow and select a different generator before proceeding. If you do, make sure to go through the entire pre-execution checklist once more.
+
+### 3. Understand Repo Context
+
+Before generating, examine the target area of the codebase:
+
+- Look at similar existing artifacts (other libraries, applications, etc.)
+- Identify patterns and conventions used in the repo
+- Note naming conventions, file structures, and configuration patterns
+- Try to match these patterns when configuring the generator
+
+For example, if similar libraries are using a specific test runner, build tool or linter, try to match that if possible.
+If projects or other artifacts are organized with a specific naming convention, try to match it.
+
+### 4. Validate Required Options
+
+Ensure all required options have values:
+
+- Map the user's request to generator options
+- Infer values from context where possible
+- Ask the user for any critical missing information
+
+## Execution
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally.
+Many generators will behave differently based on where they are executed. For example, first-party nx library generators use the cwd to determine the directory that the library should be placed in. This is highly important.
+
+### Consider Dry-Run (Optional)
+
+Running with `--dry-run` first is strongly encouraged but not mandatory. Use your judgment:
+
+- For complex generators or unfamiliar territory: do a dry-run first
+- For simple, well-understood generators: may proceed directly
+- Dry-run shows file names and created/deleted/modified markers, but not content
+- There are cases where a generator does not support dry-run (for example if it had to install an npm package) - in that case --dry-run might fail. Don't be discouraged but simply move on to running the generator for real and iterating from there.
+
+### Running the Generator
+
+Execute the generator with:
+
+```bash
+nx generate <generator-name> <options> --no-interactive
+```
+
+**CRITICAL**: Always include `--no-interactive` to prevent prompts that would hang the execution.
+
+Example:
+
+```bash
+nx generate @nx/react:library --name=my-utils --no-interactive
+```
+
+### Handling Generator Failures
+
+If the generator fails:
+
+1. **Diagnose the error** - Read the error message carefully
+2. **Identify the cause** - Missing options, invalid values, conflicts, etc.
+3. **Attempt automatic fix** - Adjust options or resolve conflicts
+4. **Retry** - Run the generator again with corrected options
+
+Common failure reasons:
+
+- Missing required options
+- Invalid option values
+- Conflicting with existing files
+- Missing dependencies
+- Generator doesn't support certain flag combinations
+
+## Post-Generation
+
+### 1. Modify Generated Code (If Needed)
+
+Generators provide a starting point, but the output may need adjustment to match the user's specific requirements:
+
+- Add or modify functionality as requested
+- Adjust imports, exports, or configurations
+- Integrate with existing code patterns in the repo
+
+### 2. Format Code
+
+Run formatting on all generated/modified files:
+
+```bash
+nx format --fix
+```
+
+Languages other than javascript/typescript might need other formatting invocations too.
+
+### 3. Run Verification
+
+Verify that the generated code works correctly. What this looks like will vary depending on the type of generator and the targets available.
+If the generator created a new project, run its targets directly
+Use your best judgement to determine what needs to be verified.
+
+Example:
+
+```bash
+nx lint <new-project>
+nx test <new-project>
+nx build <new-project>
+```
+
+### 4. Handle Verification Failures
+
+When verification fails:
+
+**If scope is manageable** (a few lint errors, minor type issues):
+
+- Fix the issues
+- Re-run verification to confirm
+
+**If issues are extensive** (many errors, complex problems):
+
+- Attempt simple, obvious fixes first
+- If still failing, escalate to the user with:
+  - Description of what was generated
+  - What verification is failing
+  - What you've attempted to fix
+  - Remaining issues that need user input
+
+## Error Handling
+
+### Generator Failures
+
+- Check the error message for specific causes
+- Verify all required options are provided
+- Check for conflicts with existing files
+- Ensure the generator name and options are correct
+
+### Missing Options
+
+- Consult the generator schema for required fields
+- Infer values from context when reasonable
+- Ask the user for values that cannot be inferred
+
+## Key Principles
+
+1. **Local generators first** - Always prefer workspace/local generators over external plugin generators when both could work
+
+2. **Understand before running** - Read both the schema AND the source code to fully understand what will happen
+
+3. **No prompts** - Always use `--no-interactive` to prevent hanging
+
+4. **Generators are starting points** - Modify the output as needed to fully satisfy the user's requirements
+
+5. **Verify changes work** - Don't just generate; ensure the code builds, lints, and tests pass
+
+6. **Be proactive about fixes** - Don't just report errors; attempt to resolve them automatically when possible
+
+7. **Match repo patterns** - Study existing similar code in the repo and match its conventions

.cursor/skills/nx-plugins/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: nx-plugins
+description: Find and add Nx plugins. USE WHEN user wants to discover available plugins, install a new plugin, or add support for a specific framework or technology to the workspace.
+---
+
+## Finding and Installing new plugins
+
+- List plugins: `pnpm nx list`
+- Install plugins `pnpm nx add <plugin>`. Example: `pnpm nx add @nx/react`.

.cursor/skills/nx-run-tasks/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: nx-run-tasks
+description: Helps with running tasks in an Nx workspace. USE WHEN the user wants to execute build, test, lint, serve, or run any other tasks defined in the workspace.
+---
+
+You can run tasks with Nx in the following way.
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally. Look at the package.json or lockfile to determine which package manager is in use.
+
+For more details on any command, run it with `--help` (e.g. `nx run-many --help`, `nx affected --help`).
+
+## Understand which tasks can be run
+
+You can check those via `nx show project <projectname> --json`, for example `nx show project myapp --json`. It contains a `targets` section which has information about targets that can be run. You can also just look at the `package.json` scripts or `project.json` targets, but you might miss out on inferred tasks by Nx plugins.
+
+## Run a single task
+
+```
+nx run <project>:<task>
+```
+
+where `project` is the project name defined in `package.json` or `project.json` (if present).
+
+## Run multiple tasks
+
+```
+nx run-many -t build test lint typecheck
+```
+
+You can pass a `-p` flag to filter to specific projects, otherwise it runs on all projects. You can also use `--exclude` to exclude projects, and `--parallel` to control the number of parallel processes (default is 3).
+
+Examples:
+
+- `nx run-many -t test -p proj1 proj2` — test specific projects
+- `nx run-many -t test --projects=*-app --exclude=excluded-app` — test projects matching a pattern
+- `nx run-many -t test --projects=tag:api-*` — test projects by tag
+
+## Run tasks for affected projects
+
+Use `nx affected` to only run tasks on projects that have been changed and projects that depend on changed projects. This is especially useful in CI and for large workspaces.
+
+```
+nx affected -t build test lint
+```
+
+By default it compares against the base branch. You can customize this:
+
+- `nx affected -t test --base=main --head=HEAD` — compare against a specific base and head
+- `nx affected -t test --files=libs/mylib/src/index.ts` — specify changed files directly
+
+## Useful flags
+
+These flags work with `run`, `run-many`, and `affected`:
+
+- `--skipNxCache` — rerun tasks even when results are cached
+- `--verbose` — print additional information such as stack traces
+- `--nxBail` — stop execution after the first failed task
+- `--configuration=<name>` — use a specific configuration (e.g. `production`)

.cursor/skills/nx-workspace/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: nx-workspace
+description: "Explore and understand Nx workspaces. USE WHEN answering any questions about the nx workspace, the projects in it or tasks to run. EXAMPLES: 'What projects are in this workspace?', 'How is project X configured?', 'What targets can I run?', 'What's affected by my changes?', 'Which projects depend on library Y?', or any questions about Nx workspace structure, project configuration, or available tasks."
+---
+
+# Nx Workspace Exploration
+
+This skill provides read-only exploration of Nx workspaces. Use it to understand workspace structure, project configuration, available targets, and dependencies.
+
+Keep in mind that you might have to prefix commands with `npx`/`pnpx`/`yarn` if nx isn't installed globally. Check the lockfile to determine the package manager in use.
+
+## Listing Projects
+
+Use `nx show projects` to list projects in the workspace.
+
+```bash
+# List all projects
+nx show projects
+
+# Filter by pattern (glob)
+nx show projects --projects "apps/*"
+nx show projects --projects "shared-*"
+
+# Filter by project type
+nx show projects --type app
+nx show projects --type lib
+nx show projects --type e2e
+
+# Filter by target (projects that have a specific target)
+nx show projects --withTarget build
+nx show projects --withTarget e2e
+
+# Find affected projects (changed since base branch)
+nx show projects --affected
+nx show projects --affected --base=main
+nx show projects --affected --type app
+
+# Combine filters
+nx show projects --type lib --withTarget test
+nx show projects --affected --exclude="*-e2e"
+
+# Output as JSON
+nx show projects --json
+```
+
+## Project Configuration
+
+Use `nx show project <name> --json` to get the full resolved configuration for a project.
+
+**Important**: Do NOT read `project.json` directly - it only contains partial configuration. The `nx show project` command returns the full resolved config including inferred targets from plugins.
+
+You can read the full project schema at `node_modules/nx/schemas/project-schema.json` to understand nx project configuration options.
+
+```bash
+# Get full project configuration
+nx show project my-app --json
+
+# Extract specific parts from the JSON
+nx show project my-app --json | jq '.targets'
+nx show project my-app --json | jq '.targets.build'
+nx show project my-app --json | jq '.targets | keys'
+
+
+# Check project metadata
+nx show project my-app --json | jq '{name, root, sourceRoot, projectType, tags}'
+```
+
+## Target Information
+
+Targets define what tasks can be run on a project.
+
+```bash
+# List all targets for a project
+nx show project my-app --json | jq '.targets | keys'
+
+# Get full target configuration
+nx show project my-app --json | jq '.targets.build'
+
+# Check target executor/command
+nx show project my-app --json | jq '.targets.build.executor'
+nx show project my-app --json | jq '.targets.build.command'
+
+# View target options
+nx show project my-app --json | jq '.targets.build.options'
+
+# Check target inputs/outputs (for caching)
+nx show project my-app --json | jq '.targets.build.inputs'
+nx show project my-app --json | jq '.targets.build.outputs'
+
+# Find projects with a specific target
+nx show projects --withTarget serve
+nx show projects --withTarget e2e
+```
+
+## Workspace Configuration
+
+Read `nx.json` directly for workspace-level configuration.
+You can read the full project schema at `node_modules/nx/schemas/nx-schema.json` to understand nx project configuration options.
+
+```bash
+# Read the full nx.json
+cat nx.json
+
+# Or use jq for specific sections
+cat nx.json | jq '.targetDefaults'
+cat nx.json | jq '.namedInputs'
+cat nx.json | jq '.plugins'
+cat nx.json | jq '.generators'
+```
+
+Key nx.json sections:
+
+- `targetDefaults` - Default configuration applied to all targets of a given name
+- `namedInputs` - Reusable input definitions for caching
+- `plugins` - Nx plugins and their configuration
+- ...and much more, read the schema or nx.json for details
+
+## Affected Projects
+
+Find projects affected by changes in the current branch.
+
+```bash
+# Affected since base branch (auto-detected)
+nx show projects --affected
+
+# Affected with explicit base
+nx show projects --affected --base=main
+nx show projects --affected --base=origin/main
+
+# Affected between two commits
+nx show projects --affected --base=abc123 --head=def456
+
+# Affected apps only
+nx show projects --affected --type app
+
+# Affected excluding e2e projects
+nx show projects --affected --exclude="*-e2e"
+
+# Affected by uncommitted changes
+nx show projects --affected --uncommitted
+
+# Affected by untracked files
+nx show projects --affected --untracked
+```
+
+## Common Exploration Patterns
+
+### "What's in this workspace?"
+
+```bash
+nx show projects
+nx show projects --type app
+nx show projects --type lib
+```
+
+### "How do I build/test/lint project X?"
+
+```bash
+nx show project X --json | jq '.targets | keys'
+nx show project X --json | jq '.targets.build'
+```
+
+### "What depends on library Y?"
+
+```bash
+# Find projects that may depend on Y by searching for imports
+# (Nx doesn't have a direct "dependents" command via CLI)
+grep -r "from '@myorg/Y'" --include="*.ts" --include="*.tsx" apps/ libs/
+```
+
+### "What configuration options are available?"
+
+```bash
+cat node_modules/nx/schemas/nx-schema.json | jq '.properties | keys'
+cat node_modules/nx/schemas/project-schema.json | jq '.properties | keys'
+```
+
+### "Why is project X affected?"
+
+```bash
+# Check what files changed
+git diff --name-only main
+
+# See which project owns those files
+nx show project X --json | jq '.root'
+```

.eslintignore

@@ -1 +0,0 @@
-node_modules

.eslintrc.json

@@ -1,101 +0,0 @@
-{
-  "root": true,
-  "parser": "@typescript-eslint/parser",
-  "env": {
-    "node": true
-  },
-  "ignorePatterns": ["**/*.ts", "**/test-output"],
-  "plugins": ["@typescript-eslint", "@nx"],
-  "extends": ["plugin:storybook/recommended"],
-  "rules": {
-    "@typescript-eslint/explicit-module-boundary-types": "off",
-    "no-restricted-imports": [
-      "error",
-      {
-        "paths": [
-          {
-            "name": "create-nx-workspace",
-            "message": "Please import utils from nx or @nx/devkit instead."
-          },
-          {
-            "name": "node-fetch",
-            "message": "Please default to native fetch instead of 'node-fetch'."
-          }
-        ]
-      }
-    ],
-    "@typescript-eslint/no-restricted-imports": [
-      "error",
-      {
-        "patterns": [
-          {
-            "group": ["nx/src/plugins/js*"],
-            "message": "Imports from 'nx/src/plugins/js' are not allowed. Use '@nx/js' instead"
-          },
-          {
-            "group": ["**/native-bindings", "**/native-bindings.js", ""],
-            "message": "Direct imports from native-bindings.js are not allowed. Import from index.js instead."
-          }
-        ]
-      }
-    ],
-    "storybook/no-uninstalled-addons": [
-      "error",
-      {
-        "ignore": ["@nx/react/plugins/storybook"],
-        "packageJsonLocation": "../../package.json"
-      }
-    ]
-  },
-  "overrides": [
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser",
-      "rules": {}
-    },
-    {
-      "files": ["**/executors/**/schema.json", "**/generators/**/schema.json"],
-      "rules": {
-        "@nx/workspace/valid-schema-description": "error"
-      }
-    },
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {
-        "@nx/enforce-module-boundaries": [
-          "error",
-          {
-            "enforceBuildableLibDependency": true,
-            "checkDynamicDependenciesExceptions": [".*"],
-            "allow": [],
-            "depConstraints": [
-              {
-                "sourceTag": "*",
-                "onlyDependOnLibsWithTags": ["*"]
-              }
-            ]
-          }
-        ],
-        "@nx/workspace/valid-command-object": "error"
-      }
-    },
-    {
-      "files": ["pnpm-lock.yaml"],
-      "parser": "./tools/eslint-rules/raw-file-parser.js",
-      "rules": {
-        "@nx/workspace/ensure-pnpm-lock-version": [
-          "error",
-          {
-            "version": "9.0"
-          }
-        ]
-      }
-    },
-    {
-      "files": ["*.ts"],
-      "rules": {
-        "@angular-eslint/prefer-standalone": "off"
-      }
-    }
-  ]
-}

.gemini/commands/ci-monitor.toml

@@ -0,0 +1,438 @@
+description = "Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting."
+prompt = """
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+{{args}}
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `{{args}}` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \\| Elapsed: Xm \\| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```"""

.gemini/skills/ci-monitor/skill.md

@@ -0,0 +1,437 @@
+---
+name: ci-monitor
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+$ARGUMENTS
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `$ARGUMENTS` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.gemini/skills/nx-generate/skill.md

@@ -0,0 +1,228 @@
+---
+name: nx-generate
+description: Generate code using nx generators. USE WHEN scaffolding code or transforming existing code - for example creating libraries or applications, or anything else that is boilerplate code or automates repetitive tasks. ALWAYS use this first when generating code with Nx instead of calling MCP tools or running nx generate immediately.
+---
+
+# Run Nx Generator
+
+Nx generators are powerful tools that scaffold projects, make automated code migrations or automate repetitive tasks in a monorepo. They ensure consistency across the codebase and reduce boilerplate work.
+
+This skill applies when the user wants to:
+
+- Create new projects like libraries or applications
+- Scaffold features or boilerplate code
+- Run workspace-specific or custom generators
+- Do anything else that an nx generator exists for
+
+## Generator Discovery Flow
+
+### Step 1: List Available Generators
+
+Use the Nx CLI to discover available generators:
+
+- List all generators for a plugin: `npx nx list @nx/react`
+- View available plugins: `npx nx list`
+
+This includes:
+
+- Plugin generators (e.g., `@nx/react:library`, `@nx/js:library`)
+- Local workspace generators (defined in the repo's own plugins)
+
+### Step 2: Match Generator to User Request
+
+Based on the user's request, identify which generator(s) could fulfill their needs. Consider:
+
+- What artifact type they want to create (library, application, etc.)
+- Which framework or technology stack is relevant
+- Whether they mentioned specific generator names
+
+**IMPORTANT**: When both a local workspace generator and an external plugin generator could satisfy the request, **always prefer the local workspace generator**. Local generators are customized for the specific repo's patterns and conventions.
+
+It's possible that the user request is something that no Nx generator exists for whatsoever. In this case, you can stop using this skill and try to help the user another way. HOWEVER, the burden of proof for this is high. Before aborting, carefully consider each and every generator that's available. Look into details for any that could be related in any way before making this decision.
+
+## Pre-Execution Checklist
+
+Before running any generator, complete these steps:
+
+### 1. Fetch Generator Schema
+
+Use the `--help` flag to understand all available options:
+
+```bash
+npx nx g @nx/react:library --help
+```
+
+Pay attention to:
+
+- Required options that must be provided
+- Optional options that may be relevant to the user's request
+- Default values that might need to be overridden
+
+### 2. Read Generator Source Code
+
+Understanding what the generator actually does helps you:
+
+- Know what files will be created/modified
+- Understand any side effects (updating configs, installing deps, etc.)
+- Identify options that might not be obvious from the schema
+
+To find generator source code:
+
+- For plugin generators: Use `node -e "console.log(require.resolve('@nx/<plugin>/generators.json'));"` to find the generators.json, then locate the source from there
+- If that fails, read directly from `node_modules/<plugin>/generators.json`
+- For local generators: They are typically in `tools/generators/` or a local plugin directory. You can search the repo for the generator name to find it.
+
+### 2.5 Reevaluate if the generator is right
+
+Once you have built up an understanding of what the selected generator does, reconsider: Is this the right generator to service the user request?
+If not, it's okay to go back to the Generator Discovery Flow and select a different generator before proceeding. If you do, make sure to go through the entire pre-execution checklist once more.
+
+### 3. Understand Repo Context
+
+Before generating, examine the target area of the codebase:
+
+- Look at similar existing artifacts (other libraries, applications, etc.)
+- Identify patterns and conventions used in the repo
+- Note naming conventions, file structures, and configuration patterns
+- Try to match these patterns when configuring the generator
+
+For example, if similar libraries are using a specific test runner, build tool or linter, try to match that if possible.
+If projects or other artifacts are organized with a specific naming convention, try to match it.
+
+### 4. Validate Required Options
+
+Ensure all required options have values:
+
+- Map the user's request to generator options
+- Infer values from context where possible
+- Ask the user for any critical missing information
+
+## Execution
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally.
+Many generators will behave differently based on where they are executed. For example, first-party nx library generators use the cwd to determine the directory that the library should be placed in. This is highly important.
+
+### Consider Dry-Run (Optional)
+
+Running with `--dry-run` first is strongly encouraged but not mandatory. Use your judgment:
+
+- For complex generators or unfamiliar territory: do a dry-run first
+- For simple, well-understood generators: may proceed directly
+- Dry-run shows file names and created/deleted/modified markers, but not content
+- There are cases where a generator does not support dry-run (for example if it had to install an npm package) - in that case --dry-run might fail. Don't be discouraged but simply move on to running the generator for real and iterating from there.
+
+### Running the Generator
+
+Execute the generator with:
+
+```bash
+nx generate <generator-name> <options> --no-interactive
+```
+
+**CRITICAL**: Always include `--no-interactive` to prevent prompts that would hang the execution.
+
+Example:
+
+```bash
+nx generate @nx/react:library --name=my-utils --no-interactive
+```
+
+### Handling Generator Failures
+
+If the generator fails:
+
+1. **Diagnose the error** - Read the error message carefully
+2. **Identify the cause** - Missing options, invalid values, conflicts, etc.
+3. **Attempt automatic fix** - Adjust options or resolve conflicts
+4. **Retry** - Run the generator again with corrected options
+
+Common failure reasons:
+
+- Missing required options
+- Invalid option values
+- Conflicting with existing files
+- Missing dependencies
+- Generator doesn't support certain flag combinations
+
+## Post-Generation
+
+### 1. Modify Generated Code (If Needed)
+
+Generators provide a starting point, but the output may need adjustment to match the user's specific requirements:
+
+- Add or modify functionality as requested
+- Adjust imports, exports, or configurations
+- Integrate with existing code patterns in the repo
+
+### 2. Format Code
+
+Run formatting on all generated/modified files:
+
+```bash
+nx format --fix
+```
+
+Languages other than javascript/typescript might need other formatting invocations too.
+
+### 3. Run Verification
+
+Verify that the generated code works correctly. What this looks like will vary depending on the type of generator and the targets available.
+If the generator created a new project, run its targets directly
+Use your best judgement to determine what needs to be verified.
+
+Example:
+
+```bash
+nx lint <new-project>
+nx test <new-project>
+nx build <new-project>
+```
+
+### 4. Handle Verification Failures
+
+When verification fails:
+
+**If scope is manageable** (a few lint errors, minor type issues):
+
+- Fix the issues
+- Re-run verification to confirm
+
+**If issues are extensive** (many errors, complex problems):
+
+- Attempt simple, obvious fixes first
+- If still failing, escalate to the user with:
+  - Description of what was generated
+  - What verification is failing
+  - What you've attempted to fix
+  - Remaining issues that need user input
+
+## Error Handling
+
+### Generator Failures
+
+- Check the error message for specific causes
+- Verify all required options are provided
+- Check for conflicts with existing files
+- Ensure the generator name and options are correct
+
+### Missing Options
+
+- Consult the generator schema for required fields
+- Infer values from context when reasonable
+- Ask the user for values that cannot be inferred
+
+## Key Principles
+
+1. **Local generators first** - Always prefer workspace/local generators over external plugin generators when both could work
+
+2. **Understand before running** - Read both the schema AND the source code to fully understand what will happen
+
+3. **No prompts** - Always use `--no-interactive` to prevent hanging
+
+4. **Generators are starting points** - Modify the output as needed to fully satisfy the user's requirements
+
+5. **Verify changes work** - Don't just generate; ensure the code builds, lints, and tests pass
+
+6. **Be proactive about fixes** - Don't just report errors; attempt to resolve them automatically when possible
+
+7. **Match repo patterns** - Study existing similar code in the repo and match its conventions

.gemini/skills/nx-plugins/skill.md

@@ -0,0 +1,9 @@
+---
+name: nx-plugins
+description: Find and add Nx plugins. USE WHEN user wants to discover available plugins, install a new plugin, or add support for a specific framework or technology to the workspace.
+---
+
+## Finding and Installing new plugins
+
+- List plugins: `pnpm nx list`
+- Install plugins `pnpm nx add <plugin>`. Example: `pnpm nx add @nx/react`.

.gemini/skills/nx-run-tasks/skill.md

@@ -0,0 +1,58 @@
+---
+name: nx-run-tasks
+description: Helps with running tasks in an Nx workspace. USE WHEN the user wants to execute build, test, lint, serve, or run any other tasks defined in the workspace.
+---
+
+You can run tasks with Nx in the following way.
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally. Look at the package.json or lockfile to determine which package manager is in use.
+
+For more details on any command, run it with `--help` (e.g. `nx run-many --help`, `nx affected --help`).
+
+## Understand which tasks can be run
+
+You can check those via `nx show project <projectname> --json`, for example `nx show project myapp --json`. It contains a `targets` section which has information about targets that can be run. You can also just look at the `package.json` scripts or `project.json` targets, but you might miss out on inferred tasks by Nx plugins.
+
+## Run a single task
+
+```
+nx run <project>:<task>
+```
+
+where `project` is the project name defined in `package.json` or `project.json` (if present).
+
+## Run multiple tasks
+
+```
+nx run-many -t build test lint typecheck
+```
+
+You can pass a `-p` flag to filter to specific projects, otherwise it runs on all projects. You can also use `--exclude` to exclude projects, and `--parallel` to control the number of parallel processes (default is 3).
+
+Examples:
+
+- `nx run-many -t test -p proj1 proj2` — test specific projects
+- `nx run-many -t test --projects=*-app --exclude=excluded-app` — test projects matching a pattern
+- `nx run-many -t test --projects=tag:api-*` — test projects by tag
+
+## Run tasks for affected projects
+
+Use `nx affected` to only run tasks on projects that have been changed and projects that depend on changed projects. This is especially useful in CI and for large workspaces.
+
+```
+nx affected -t build test lint
+```
+
+By default it compares against the base branch. You can customize this:
+
+- `nx affected -t test --base=main --head=HEAD` — compare against a specific base and head
+- `nx affected -t test --files=libs/mylib/src/index.ts` — specify changed files directly
+
+## Useful flags
+
+These flags work with `run`, `run-many`, and `affected`:
+
+- `--skipNxCache` — rerun tasks even when results are cached
+- `--verbose` — print additional information such as stack traces
+- `--nxBail` — stop execution after the first failed task
+- `--configuration=<name>` — use a specific configuration (e.g. `production`)

.gemini/skills/nx-workspace/skill.md

@@ -0,0 +1,186 @@
+---
+name: nx-workspace
+description: "Explore and understand Nx workspaces. USE WHEN answering any questions about the nx workspace, the projects in it or tasks to run. EXAMPLES: 'What projects are in this workspace?', 'How is project X configured?', 'What targets can I run?', 'What's affected by my changes?', 'Which projects depend on library Y?', or any questions about Nx workspace structure, project configuration, or available tasks."
+---
+
+# Nx Workspace Exploration
+
+This skill provides read-only exploration of Nx workspaces. Use it to understand workspace structure, project configuration, available targets, and dependencies.
+
+Keep in mind that you might have to prefix commands with `npx`/`pnpx`/`yarn` if nx isn't installed globally. Check the lockfile to determine the package manager in use.
+
+## Listing Projects
+
+Use `nx show projects` to list projects in the workspace.
+
+```bash
+# List all projects
+nx show projects
+
+# Filter by pattern (glob)
+nx show projects --projects "apps/*"
+nx show projects --projects "shared-*"
+
+# Filter by project type
+nx show projects --type app
+nx show projects --type lib
+nx show projects --type e2e
+
+# Filter by target (projects that have a specific target)
+nx show projects --withTarget build
+nx show projects --withTarget e2e
+
+# Find affected projects (changed since base branch)
+nx show projects --affected
+nx show projects --affected --base=main
+nx show projects --affected --type app
+
+# Combine filters
+nx show projects --type lib --withTarget test
+nx show projects --affected --exclude="*-e2e"
+
+# Output as JSON
+nx show projects --json
+```
+
+## Project Configuration
+
+Use `nx show project <name> --json` to get the full resolved configuration for a project.
+
+**Important**: Do NOT read `project.json` directly - it only contains partial configuration. The `nx show project` command returns the full resolved config including inferred targets from plugins.
+
+You can read the full project schema at `node_modules/nx/schemas/project-schema.json` to understand nx project configuration options.
+
+```bash
+# Get full project configuration
+nx show project my-app --json
+
+# Extract specific parts from the JSON
+nx show project my-app --json | jq '.targets'
+nx show project my-app --json | jq '.targets.build'
+nx show project my-app --json | jq '.targets | keys'
+
+
+# Check project metadata
+nx show project my-app --json | jq '{name, root, sourceRoot, projectType, tags}'
+```
+
+## Target Information
+
+Targets define what tasks can be run on a project.
+
+```bash
+# List all targets for a project
+nx show project my-app --json | jq '.targets | keys'
+
+# Get full target configuration
+nx show project my-app --json | jq '.targets.build'
+
+# Check target executor/command
+nx show project my-app --json | jq '.targets.build.executor'
+nx show project my-app --json | jq '.targets.build.command'
+
+# View target options
+nx show project my-app --json | jq '.targets.build.options'
+
+# Check target inputs/outputs (for caching)
+nx show project my-app --json | jq '.targets.build.inputs'
+nx show project my-app --json | jq '.targets.build.outputs'
+
+# Find projects with a specific target
+nx show projects --withTarget serve
+nx show projects --withTarget e2e
+```
+
+## Workspace Configuration
+
+Read `nx.json` directly for workspace-level configuration.
+You can read the full project schema at `node_modules/nx/schemas/nx-schema.json` to understand nx project configuration options.
+
+```bash
+# Read the full nx.json
+cat nx.json
+
+# Or use jq for specific sections
+cat nx.json | jq '.targetDefaults'
+cat nx.json | jq '.namedInputs'
+cat nx.json | jq '.plugins'
+cat nx.json | jq '.generators'
+```
+
+Key nx.json sections:
+
+- `targetDefaults` - Default configuration applied to all targets of a given name
+- `namedInputs` - Reusable input definitions for caching
+- `plugins` - Nx plugins and their configuration
+- ...and much more, read the schema or nx.json for details
+
+## Affected Projects
+
+Find projects affected by changes in the current branch.
+
+```bash
+# Affected since base branch (auto-detected)
+nx show projects --affected
+
+# Affected with explicit base
+nx show projects --affected --base=main
+nx show projects --affected --base=origin/main
+
+# Affected between two commits
+nx show projects --affected --base=abc123 --head=def456
+
+# Affected apps only
+nx show projects --affected --type app
+
+# Affected excluding e2e projects
+nx show projects --affected --exclude="*-e2e"
+
+# Affected by uncommitted changes
+nx show projects --affected --uncommitted
+
+# Affected by untracked files
+nx show projects --affected --untracked
+```
+
+## Common Exploration Patterns
+
+### "What's in this workspace?"
+
+```bash
+nx show projects
+nx show projects --type app
+nx show projects --type lib
+```
+
+### "How do I build/test/lint project X?"
+
+```bash
+nx show project X --json | jq '.targets | keys'
+nx show project X --json | jq '.targets.build'
+```
+
+### "What depends on library Y?"
+
+```bash
+# Find projects that may depend on Y by searching for imports
+# (Nx doesn't have a direct "dependents" command via CLI)
+grep -r "from '@myorg/Y'" --include="*.ts" --include="*.tsx" apps/ libs/
+```
+
+### "What configuration options are available?"
+
+```bash
+cat node_modules/nx/schemas/nx-schema.json | jq '.properties | keys'
+cat node_modules/nx/schemas/project-schema.json | jq '.properties | keys'
+```
+
+### "Why is project X affected?"
+
+```bash
+# Check what files changed
+git diff --name-only main
+
+# See which project owns those files
+nx show project X --json | jq '.root'
+```

.github/agents/ci-watcher.agent.md

@@ -0,0 +1,478 @@
+---
+description: Polls Nx Cloud CI pipeline and self-healing status. Returns structured state when actionable. Spawned by /nx-cloud-ci-monitor command to monitor CI Attempt status.
+---
+
+# CI Watcher Subagent
+
+You are a CI monitoring subagent responsible for polling Nx Cloud CI Attempt status and self-healing state. You report status back to the main agent - you do NOT make apply/reject decisions.
+
+## Your Responsibilities
+
+1. Poll CI status using the `ci_information` MCP tool
+2. Implement exponential backoff between polls
+3. Return structured state when an actionable condition is reached
+4. Track iteration count and elapsed time
+5. Output status updates based on verbosity level
+
+## Input Parameters (from Main Agent)
+
+The main agent may provide these optional parameters in the prompt:
+
+| Parameter           | Description                                              |
+| ------------------- | -------------------------------------------------------- |
+| `branch`            | Branch to monitor (auto-detected if not provided)        |
+| `expectedCommitSha` | Commit SHA that should trigger a new CI Attempt          |
+| `previousCipeUrl`   | CI Attempt URL before the action (to detect change)      |
+| `subagentTimeout`   | Polling timeout in minutes (default: 60)                 |
+| `verbosity`         | Output level: minimal, medium, verbose (default: medium) |
+
+When `expectedCommitSha` or `previousCipeUrl` is provided, you must detect whether a new CI Attempt has spawned.
+
+## MCP Tool Reference
+
+### `ci_information`
+
+**Input:**
+
+```json
+{
+  "branch": "string (optional, defaults to current git branch)",
+  "select": "string (optional, comma-separated field names)",
+  "pageToken": "number (optional, 0-based pagination for long strings)"
+}
+```
+
+**Output:**
+
+```json
+{
+  "cipeStatus": "NOT_STARTED | IN_PROGRESS | SUCCEEDED | FAILED | CANCELED | TIMED_OUT",
+  "cipeUrl": "string",
+  "branch": "string",
+  "commitSha": "string | null",
+  "failedTaskIds": "string[]",
+  "verifiedTaskIds": "string[]",
+  "selfHealingEnabled": "boolean",
+  "selfHealingStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "verificationStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "userAction": "NONE | APPLIED | REJECTED | APPLIED_LOCALLY | APPLIED_AUTOMATICALLY | null",
+  "failureClassification": "string | null",
+  "taskOutputSummary": "string | null",
+  "suggestedFixReasoning": "string | null",
+  "suggestedFixDescription": "string | null",
+  "suggestedFix": "string | null",
+  "shortLink": "string | null",
+  "couldAutoApplyTasks": "boolean | null",
+  "confidence": "number | null",
+  "confidenceReasoning": "string | null"
+}
+```
+
+**Select Parameter:**
+
+| Usage           | Returns                                                     |
+| --------------- | ----------------------------------------------------------- |
+| No `select`     | Formatted overview (truncated, not recommended for polling) |
+| Single field    | Raw value with pagination for long strings                  |
+| Multiple fields | Object with requested field values                          |
+
+**Field Sets for Efficient Polling:**
+
+```yaml
+WAIT_FIELDS:
+  'cipeUrl,commitSha,cipeStatus'
+  # Minimal fields for detecting new CI Attempt
+
+LIGHT_FIELDS:
+  'cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning'
+  # Status fields for determining actionable state
+
+HEAVY_FIELDS:
+  'taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription'
+  # Large content fields - fetch only when returning to main agent
+```
+
+## Initial Wait
+
+Before first poll, wait based on context:
+
+- **Fresh start (no expected CIPE):** Wait 60 seconds to allow CI to start
+- **Expecting new CIPE:** Wait 30 seconds (action already triggered)
+
+**IMPORTANT:** Always run sleep in foreground, NOT as background command.
+
+```bash
+sleep 60  # or 30 if expecting new CIPE (FOREGROUND, not background)
+```
+
+## Two-Phase Operation
+
+The subagent operates in one of two modes depending on input:
+
+### Mode 1: Fresh Start (no `expectedCommitSha` or `previousCipeUrl`)
+
+Normal polling - process whatever CIPE is returned by `ci_information`.
+
+### Mode 2: Wait-for-New-CIPE (when `expectedCommitSha` or `previousCipeUrl` provided)
+
+**CRITICAL**: When expecting a new CIPE, the subagent must **completely ignore** the old/stale CIPE. Do NOT process its status, do NOT return actionable states based on it.
+
+#### Phase A: Wait Mode
+
+1. Start a **new-CIPE timeout** timer (default: 30 minutes)
+2. On each poll of `ci_information`:
+   - Check if CIPE is NEW:
+     - `cipeUrl` differs from `previousCipeUrl` → **new CIPE detected**
+     - `commitSha` matches `expectedCommitSha` → **correct CIPE detected**
+   - If still OLD CIPE: **ignore all status fields**, just wait and poll again
+   - Do NOT return `fix_available`, `ci_success`, etc. based on old CIPE!
+3. Output wait status (see below)
+4. If timeout (30 min) reached → return `no_new_cipe`
+
+#### Phase B: Normal Polling (after new CIPE detected)
+
+Once new CIPE is detected:
+
+1. Clear the new-CIPE timeout
+2. Switch to normal polling mode
+3. Process the NEW CIPE's status normally
+4. Return when actionable state reached
+
+### Wait Mode Output
+
+While in wait mode, output clearly that you're waiting (not processing):
+
+```
+[CI Monitor] ═══════════════════════════════════════════════════════
+[CI Monitor] WAIT MODE - Expecting new CI Attempt
+[CI Monitor] Expected SHA: <expectedCommitSha>
+[CI Monitor] Previous CI Attempt: <previousCipeUrl>
+[CI Monitor] ═══════════════════════════════════════════════════════
+
+[CI Monitor] Polling... (elapsed: 0m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 1m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 2m 30s)
+[CI Monitor] ✓ New CI Attempt detected! URL: <newCipeUrl>, SHA: <newCommitSha>
+[CI Monitor] Switching to normal polling mode...
+```
+
+### Why This Matters (Context Preservation)
+
+**The problem**: Stale CIPE data can be very large:
+
+- `taskOutputSummary`: potentially thousands of characters of build/test output
+- `suggestedFix`: entire patch files
+- `suggestedFixReasoning`: detailed explanation
+
+If subagent returns stale CIPE data to main agent, it **pollutes main agent's context** with useless information (we already processed that CIPE). This wastes valuable context window.
+
+**Without wait mode:**
+
+1. Poll `ci_information` → get old CIPE with huge data
+2. Return to main agent with all that stale data
+3. Main agent's context gets polluted with useless info
+4. Main agent has to process/ignore it anyway
+
+**With wait mode:**
+
+1. Poll `ci_information` → get old CIPE → **ignore it, don't return**
+2. Keep waiting internally (stale data stays in subagent)
+3. New CIPE appears → switch to normal mode
+4. Return to main agent with only the NEW, relevant CIPE data
+
+## Polling Loop
+
+### Subagent State Management
+
+Maintain internal accumulated state across polls:
+
+```
+accumulated_state = {}
+```
+
+### Call `ci_information` MCP Tool
+
+**Wait Mode (expecting new CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeUrl,commitSha,cipeStatus"
+})
+```
+
+Only fetch minimal fields needed to detect CI Attempt change. Do NOT fetch heavy fields - stale data wastes context.
+
+**Normal Mode (processing CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning"
+})
+```
+
+Merge response into `accumulated_state` after each poll.
+
+### Analyze Response
+
+**If in Wait Mode** (expecting new CIPE):
+
+1. Check if CIPE is new (see Two-Phase Operation above)
+2. If old CIPE → **ignore status**, output wait message, poll again
+3. If new CIPE → switch to normal mode, continue below
+
+**If in Normal Mode**:
+Based on the response, decide whether to **keep polling** or **return to main agent**.
+
+### Keep Polling When
+
+Continue polling (with backoff) if ANY of these conditions are true:
+
+| Condition                               | Reason                                   |
+| --------------------------------------- | ---------------------------------------- |
+| `cipeStatus == 'IN_PROGRESS'`           | CI still running                         |
+| `cipeStatus == 'NOT_STARTED'`           | CI hasn't started yet                    |
+| `selfHealingStatus == 'IN_PROGRESS'`    | Self-healing agent working               |
+| `selfHealingStatus == 'NOT_STARTED'`    | Self-healing not started yet             |
+| `failureClassification == 'FLAKY_TASK'` | Auto-rerun in progress                   |
+| `userAction == 'APPLIED_AUTOMATICALLY'` | New CI Attempt spawning after auto-apply |
+
+When `couldAutoApplyTasks == true`:
+
+- `verificationStatus` = `NOT_STARTED`, `IN_PROGRESS` → keep polling (verification still in progress)
+- `verificationStatus` = `COMPLETED` → return `fix_auto_applying` (auto-apply will happen, main agent spawns wait mode subagent)
+- `verificationStatus` = `FAILED`, `NOT_EXECUTABLE` → return `fix_available` (auto-apply won't happen, needs manual action)
+
+### Exponential Backoff
+
+Between polls, wait with exponential backoff:
+
+| Poll Attempt | Wait Time         |
+| ------------ | ----------------- |
+| 1st          | 60 seconds        |
+| 2nd          | 90 seconds        |
+| 3rd+         | 120 seconds (cap) |
+
+Reset to 60 seconds when state changes significantly.
+
+**IMPORTANT:** Run sleep in foreground (NOT as background command). Background sleep causes "What should Claude do?" prompts when completed.
+
+```bash
+# Example backoff - run in FOREGROUND
+sleep 60   # First wait
+sleep 90   # Second wait
+sleep 120  # Third and subsequent waits (capped)
+```
+
+### Fetch Heavy Fields on Actionable State
+
+Before returning to main agent, fetch heavy fields if the status requires them:
+
+| Status              | Heavy Fields Needed                                                            |
+| ------------------- | ------------------------------------------------------------------------------ |
+| `ci_success`        | None                                                                           |
+| `fix_auto_applying` | None                                                                           |
+| `fix_available`     | `taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription` |
+| `fix_failed`        | `taskOutputSummary`                                                            |
+| `no_fix`            | `taskOutputSummary`                                                            |
+| `environment_issue` | None                                                                           |
+| `no_new_cipe`       | None                                                                           |
+| `polling_timeout`   | None                                                                           |
+| `cipe_canceled`     | None                                                                           |
+| `cipe_timed_out`    | None                                                                           |
+
+```
+# Example: fetching heavy fields for fix_available
+ci_information({
+  branch: "<branch_name>",
+  select: "taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription"
+})
+```
+
+Merge response into `accumulated_state`, then return merged state to main agent.
+
+**Pagination:** Heavy string fields return first page only. If `hasMore` indicated, include in return format so main agent knows more content available.
+
+### Return to Main Agent When
+
+Return immediately with structured state if ANY of these conditions are true:
+
+| Status              | Condition                                                                                                                                                 |
+| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | `cipeStatus == 'SUCCEEDED'`                                                                                                                               |
+| `fix_auto_applying` | `selfHealingStatus == 'COMPLETED'` AND `couldAutoApplyTasks == true` AND `verificationStatus == 'COMPLETED'`                                              |
+| `fix_available`     | `selfHealingStatus == 'COMPLETED'` AND `suggestedFix != null` AND (`couldAutoApplyTasks != true` OR `verificationStatus` in (`FAILED`, `NOT_EXECUTABLE`)) |
+| `fix_failed`        | `selfHealingStatus == 'FAILED'`                                                                                                                           |
+| `environment_issue` | `failureClassification == 'ENVIRONMENT_STATE'`                                                                                                            |
+| `no_fix`            | `cipeStatus == 'FAILED'` AND (`selfHealingEnabled == false` OR `selfHealingStatus == 'NOT_EXECUTABLE'`)                                                   |
+| `no_new_cipe`       | `expectedCommitSha` or `previousCipeUrl` provided, but no new CI Attempt detected after 30 min                                                            |
+| `polling_timeout`   | Subagent has been polling for > configured timeout (default 60 min)                                                                                       |
+| `cipe_canceled`     | `cipeStatus == 'CANCELED'`                                                                                                                                |
+| `cipe_timed_out`    | `cipeStatus == 'TIMED_OUT'`                                                                                                                               |
+
+## Subagent Timeout
+
+Track elapsed time. If you have been polling for more than **60 minutes** (configurable via main agent), return with `status: polling_timeout`.
+
+## Return Format
+
+When returning to the main agent, provide a structured response with accumulated state:
+
+```
+## CI Monitor Result
+
+**Status:** <status>
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### CI Attempt Details
+- **Status:** <cipeStatus>
+- **URL:** <cipeUrl>
+- **Branch:** <branch>
+- **Commit:** <commitSha>
+- **Failed Tasks:** <failedTaskIds>
+- **Verified Tasks:** <verifiedTaskIds>
+
+### Self-Healing Details
+- **Enabled:** <selfHealingEnabled>
+- **Status:** <selfHealingStatus>
+- **Verification:** <verificationStatus>
+- **User Action:** <userAction>
+- **Classification:** <failureClassification>
+- **Confidence:** <confidence>
+- **Confidence Reasoning:** <confidenceReasoning>
+
+### Fix Information (if available)
+- **Short Link:** <shortLink>
+- **Description:** <suggestedFixDescription>
+- **Reasoning:** <suggestedFixReasoning>
+
+### Task Output Summary (first page)
+<taskOutputSummary>
+[MORE_CONTENT_AVAILABLE: taskOutputSummary, pageToken: 1]
+
+### Suggested Fix (first page)
+<suggestedFix>
+[MORE_CONTENT_AVAILABLE: suggestedFix, pageToken: 1]
+```
+
+### Pagination Indicators
+
+When a heavy field has more content available, append indicator:
+
+```
+[MORE_CONTENT_AVAILABLE: <fieldName>, pageToken: <nextPage>]
+```
+
+Main agent can fetch additional pages if needed using:
+
+```
+ci_information({ select: "<fieldName>", pageToken: <nextPage> })
+```
+
+Fields that may have pagination:
+
+- `taskOutputSummary` (reverse pagination - page 0 = most recent)
+- `suggestedFix` (forward pagination - page 0 = start)
+- `suggestedFixReasoning`
+
+### Return Format for `no_new_cipe`
+
+When returning with `status: no_new_cipe`, include additional context:
+
+```
+## CI Monitor Result
+
+**Status:** no_new_cipe
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### Expected CI Attempt Not Found
+- **Expected Commit SHA:** <expectedCommitSha>
+- **Previous CI Attempt URL:** <previousCipeUrl>
+- **Last Seen CI Attempt URL:** <cipeUrl>
+- **Last Seen Commit SHA:** <commitSha>
+- **New CI Attempt Timeout:** 30 minutes (exceeded)
+
+### Likely Cause
+CI workflow failed before Nx tasks could run (e.g., install step, checkout, auth).
+Check your CI provider logs for the commit <expectedCommitSha>.
+
+### Last Known CI Attempt State
+- **Status:** <cipeStatus>
+- **Branch:** <branch>
+```
+
+## Status Reporting (Verbosity-Controlled)
+
+Output is controlled by the `verbosity` parameter from the main agent:
+
+| Level     | What to Output                                                    |
+| --------- | ----------------------------------------------------------------- |
+| `minimal` | No intermediate output. Only return final result when actionable. |
+| `medium`  | Output only on significant state changes (not every poll).        |
+| `verbose` | Output detailed phase information after every poll.               |
+
+### Minimal Verbosity
+
+No output during polling. Poll silently and return when done.
+
+### Medium Verbosity (Default)
+
+Output **only when state changes significantly** to save context tokens:
+
+- `cipeStatus` changes (e.g., IN_PROGRESS → FAILED)
+- `selfHealingStatus` changes (e.g., IN_PROGRESS → COMPLETED)
+- New CI Attempt detected (in wait mode)
+
+Format: single line, no decorators:
+
+```
+[CI Monitor] CI: FAILED | Self-Healing: IN_PROGRESS | Elapsed: 4m
+```
+
+### Verbose Verbosity
+
+Output detailed phase box after every poll:
+
+```
+[CI Monitor] ─────────────────────────────────────────────────────
+[CI Monitor] Iteration <N> | Elapsed: <X>m <Y>s
+[CI Monitor]
+[CI Monitor] CI Status:          <cipeStatus>
+[CI Monitor] Self-Healing:       <selfHealingStatus>
+[CI Monitor] Verification:       <verificationStatus>
+[CI Monitor] Classification:     <failureClassification>
+[CI Monitor]
+[CI Monitor] → <human-readable phase description>
+[CI Monitor] ─────────────────────────────────────────────────────
+```
+
+### Phase Descriptions (for verbose output)
+
+| Status Combo                                                                              | Description                                 |
+| ----------------------------------------------------------------------------------------- | ------------------------------------------- |
+| `cipeStatus: IN_PROGRESS`                                                                 | "CI running..."                             |
+| `cipeStatus: NOT_STARTED`                                                                 | "Waiting for CI to start..."                |
+| `cipeStatus: FAILED` + `selfHealingStatus: NOT_STARTED`                                   | "CI failed. Self-healing starting..."       |
+| `cipeStatus: FAILED` + `selfHealingStatus: IN_PROGRESS`                                   | "CI failed. Self-healing generating fix..." |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: IN_PROGRESS` | "Fix generated! Verification running..."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: COMPLETED`   | "Fix ready! Verified successfully."         |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: FAILED`      | "Fix generated but verification failed."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: FAILED`                                        | "Self-healing could not generate a fix."    |
+| `cipeStatus: SUCCEEDED`                                                                   | "CI passed!"                                |
+
+## Important Notes
+
+- You do NOT make apply/reject decisions - that's the main agent's job
+- You do NOT perform git operations
+- You only poll and report state
+- Respect the `verbosity` parameter for output (default: medium)
+- If `ci_information` returns an error, wait and retry (count as failed poll)
+- Track consecutive failures - if 5 consecutive failures, return with `status: error`
+- When expecting new CI Attempt, track the 30-minute new-CI-Attempt timeout separately from the main polling timeout

.github/dependabot.yml

@@ -0,0 +1,18 @@
+# This configuration is here to prevent false positive alerts for __fixtures__.
+# We are intentionally disabling the PR opening feature.
+
+version: 2
+updates:
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    open-pull-requests-limit: 0
+    exclude-paths:
+      - '**/__fixtures__/**'
+
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    open-pull-requests-limit: 0

.github/prompts/ci-monitor.prompt.md

@@ -0,0 +1,437 @@
+---
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+argument-hint: '[instructions] [--max-cycles N] [--timeout MINUTES] [--verbosity minimal|medium|verbose] [--branch BRANCH] [--fresh] [--auto-fix-workflow] [--new-cipe-timeout MINUTES]'
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+${input:args}
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `${input:args}` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.github/skills/ci-monitor/SKILL.md

@@ -0,0 +1,437 @@
+---
+name: ci-monitor
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+$ARGUMENTS
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `$ARGUMENTS` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.github/skills/nx-generate/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: nx-generate
+description: Generate code using nx generators. USE WHEN scaffolding code or transforming existing code - for example creating libraries or applications, or anything else that is boilerplate code or automates repetitive tasks. ALWAYS use this first when generating code with Nx instead of calling MCP tools or running nx generate immediately.
+---
+
+# Run Nx Generator
+
+Nx generators are powerful tools that scaffold projects, make automated code migrations or automate repetitive tasks in a monorepo. They ensure consistency across the codebase and reduce boilerplate work.
+
+This skill applies when the user wants to:
+
+- Create new projects like libraries or applications
+- Scaffold features or boilerplate code
+- Run workspace-specific or custom generators
+- Do anything else that an nx generator exists for
+
+## Generator Discovery Flow
+
+### Step 1: List Available Generators
+
+Use the Nx CLI to discover available generators:
+
+- List all generators for a plugin: `npx nx list @nx/react`
+- View available plugins: `npx nx list`
+
+This includes:
+
+- Plugin generators (e.g., `@nx/react:library`, `@nx/js:library`)
+- Local workspace generators (defined in the repo's own plugins)
+
+### Step 2: Match Generator to User Request
+
+Based on the user's request, identify which generator(s) could fulfill their needs. Consider:
+
+- What artifact type they want to create (library, application, etc.)
+- Which framework or technology stack is relevant
+- Whether they mentioned specific generator names
+
+**IMPORTANT**: When both a local workspace generator and an external plugin generator could satisfy the request, **always prefer the local workspace generator**. Local generators are customized for the specific repo's patterns and conventions.
+
+It's possible that the user request is something that no Nx generator exists for whatsoever. In this case, you can stop using this skill and try to help the user another way. HOWEVER, the burden of proof for this is high. Before aborting, carefully consider each and every generator that's available. Look into details for any that could be related in any way before making this decision.
+
+## Pre-Execution Checklist
+
+Before running any generator, complete these steps:
+
+### 1. Fetch Generator Schema
+
+Use the `--help` flag to understand all available options:
+
+```bash
+npx nx g @nx/react:library --help
+```
+
+Pay attention to:
+
+- Required options that must be provided
+- Optional options that may be relevant to the user's request
+- Default values that might need to be overridden
+
+### 2. Read Generator Source Code
+
+Understanding what the generator actually does helps you:
+
+- Know what files will be created/modified
+- Understand any side effects (updating configs, installing deps, etc.)
+- Identify options that might not be obvious from the schema
+
+To find generator source code:
+
+- For plugin generators: Use `node -e "console.log(require.resolve('@nx/<plugin>/generators.json'));"` to find the generators.json, then locate the source from there
+- If that fails, read directly from `node_modules/<plugin>/generators.json`
+- For local generators: They are typically in `tools/generators/` or a local plugin directory. You can search the repo for the generator name to find it.
+
+### 2.5 Reevaluate if the generator is right
+
+Once you have built up an understanding of what the selected generator does, reconsider: Is this the right generator to service the user request?
+If not, it's okay to go back to the Generator Discovery Flow and select a different generator before proceeding. If you do, make sure to go through the entire pre-execution checklist once more.
+
+### 3. Understand Repo Context
+
+Before generating, examine the target area of the codebase:
+
+- Look at similar existing artifacts (other libraries, applications, etc.)
+- Identify patterns and conventions used in the repo
+- Note naming conventions, file structures, and configuration patterns
+- Try to match these patterns when configuring the generator
+
+For example, if similar libraries are using a specific test runner, build tool or linter, try to match that if possible.
+If projects or other artifacts are organized with a specific naming convention, try to match it.
+
+### 4. Validate Required Options
+
+Ensure all required options have values:
+
+- Map the user's request to generator options
+- Infer values from context where possible
+- Ask the user for any critical missing information
+
+## Execution
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally.
+Many generators will behave differently based on where they are executed. For example, first-party nx library generators use the cwd to determine the directory that the library should be placed in. This is highly important.
+
+### Consider Dry-Run (Optional)
+
+Running with `--dry-run` first is strongly encouraged but not mandatory. Use your judgment:
+
+- For complex generators or unfamiliar territory: do a dry-run first
+- For simple, well-understood generators: may proceed directly
+- Dry-run shows file names and created/deleted/modified markers, but not content
+- There are cases where a generator does not support dry-run (for example if it had to install an npm package) - in that case --dry-run might fail. Don't be discouraged but simply move on to running the generator for real and iterating from there.
+
+### Running the Generator
+
+Execute the generator with:
+
+```bash
+nx generate <generator-name> <options> --no-interactive
+```
+
+**CRITICAL**: Always include `--no-interactive` to prevent prompts that would hang the execution.
+
+Example:
+
+```bash
+nx generate @nx/react:library --name=my-utils --no-interactive
+```
+
+### Handling Generator Failures
+
+If the generator fails:
+
+1. **Diagnose the error** - Read the error message carefully
+2. **Identify the cause** - Missing options, invalid values, conflicts, etc.
+3. **Attempt automatic fix** - Adjust options or resolve conflicts
+4. **Retry** - Run the generator again with corrected options
+
+Common failure reasons:
+
+- Missing required options
+- Invalid option values
+- Conflicting with existing files
+- Missing dependencies
+- Generator doesn't support certain flag combinations
+
+## Post-Generation
+
+### 1. Modify Generated Code (If Needed)
+
+Generators provide a starting point, but the output may need adjustment to match the user's specific requirements:
+
+- Add or modify functionality as requested
+- Adjust imports, exports, or configurations
+- Integrate with existing code patterns in the repo
+
+### 2. Format Code
+
+Run formatting on all generated/modified files:
+
+```bash
+nx format --fix
+```
+
+Languages other than javascript/typescript might need other formatting invocations too.
+
+### 3. Run Verification
+
+Verify that the generated code works correctly. What this looks like will vary depending on the type of generator and the targets available.
+If the generator created a new project, run its targets directly
+Use your best judgement to determine what needs to be verified.
+
+Example:
+
+```bash
+nx lint <new-project>
+nx test <new-project>
+nx build <new-project>
+```
+
+### 4. Handle Verification Failures
+
+When verification fails:
+
+**If scope is manageable** (a few lint errors, minor type issues):
+
+- Fix the issues
+- Re-run verification to confirm
+
+**If issues are extensive** (many errors, complex problems):
+
+- Attempt simple, obvious fixes first
+- If still failing, escalate to the user with:
+  - Description of what was generated
+  - What verification is failing
+  - What you've attempted to fix
+  - Remaining issues that need user input
+
+## Error Handling
+
+### Generator Failures
+
+- Check the error message for specific causes
+- Verify all required options are provided
+- Check for conflicts with existing files
+- Ensure the generator name and options are correct
+
+### Missing Options
+
+- Consult the generator schema for required fields
+- Infer values from context when reasonable
+- Ask the user for values that cannot be inferred
+
+## Key Principles
+
+1. **Local generators first** - Always prefer workspace/local generators over external plugin generators when both could work
+
+2. **Understand before running** - Read both the schema AND the source code to fully understand what will happen
+
+3. **No prompts** - Always use `--no-interactive` to prevent hanging
+
+4. **Generators are starting points** - Modify the output as needed to fully satisfy the user's requirements
+
+5. **Verify changes work** - Don't just generate; ensure the code builds, lints, and tests pass
+
+6. **Be proactive about fixes** - Don't just report errors; attempt to resolve them automatically when possible
+
+7. **Match repo patterns** - Study existing similar code in the repo and match its conventions

.github/skills/nx-plugins/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: nx-plugins
+description: Find and add Nx plugins. USE WHEN user wants to discover available plugins, install a new plugin, or add support for a specific framework or technology to the workspace.
+---
+
+## Finding and Installing new plugins
+
+- List plugins: `pnpm nx list`
+- Install plugins `pnpm nx add <plugin>`. Example: `pnpm nx add @nx/react`.

.github/skills/nx-run-tasks/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: nx-run-tasks
+description: Helps with running tasks in an Nx workspace. USE WHEN the user wants to execute build, test, lint, serve, or run any other tasks defined in the workspace.
+---
+
+You can run tasks with Nx in the following way.
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally. Look at the package.json or lockfile to determine which package manager is in use.
+
+For more details on any command, run it with `--help` (e.g. `nx run-many --help`, `nx affected --help`).
+
+## Understand which tasks can be run
+
+You can check those via `nx show project <projectname> --json`, for example `nx show project myapp --json`. It contains a `targets` section which has information about targets that can be run. You can also just look at the `package.json` scripts or `project.json` targets, but you might miss out on inferred tasks by Nx plugins.
+
+## Run a single task
+
+```
+nx run <project>:<task>
+```
+
+where `project` is the project name defined in `package.json` or `project.json` (if present).
+
+## Run multiple tasks
+
+```
+nx run-many -t build test lint typecheck
+```
+
+You can pass a `-p` flag to filter to specific projects, otherwise it runs on all projects. You can also use `--exclude` to exclude projects, and `--parallel` to control the number of parallel processes (default is 3).
+
+Examples:
+
+- `nx run-many -t test -p proj1 proj2` — test specific projects
+- `nx run-many -t test --projects=*-app --exclude=excluded-app` — test projects matching a pattern
+- `nx run-many -t test --projects=tag:api-*` — test projects by tag
+
+## Run tasks for affected projects
+
+Use `nx affected` to only run tasks on projects that have been changed and projects that depend on changed projects. This is especially useful in CI and for large workspaces.
+
+```
+nx affected -t build test lint
+```
+
+By default it compares against the base branch. You can customize this:
+
+- `nx affected -t test --base=main --head=HEAD` — compare against a specific base and head
+- `nx affected -t test --files=libs/mylib/src/index.ts` — specify changed files directly
+
+## Useful flags
+
+These flags work with `run`, `run-many`, and `affected`:
+
+- `--skipNxCache` — rerun tasks even when results are cached
+- `--verbose` — print additional information such as stack traces
+- `--nxBail` — stop execution after the first failed task
+- `--configuration=<name>` — use a specific configuration (e.g. `production`)

.github/skills/nx-workspace/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: nx-workspace
+description: "Explore and understand Nx workspaces. USE WHEN answering any questions about the nx workspace, the projects in it or tasks to run. EXAMPLES: 'What projects are in this workspace?', 'How is project X configured?', 'What targets can I run?', 'What's affected by my changes?', 'Which projects depend on library Y?', or any questions about Nx workspace structure, project configuration, or available tasks."
+---
+
+# Nx Workspace Exploration
+
+This skill provides read-only exploration of Nx workspaces. Use it to understand workspace structure, project configuration, available targets, and dependencies.
+
+Keep in mind that you might have to prefix commands with `npx`/`pnpx`/`yarn` if nx isn't installed globally. Check the lockfile to determine the package manager in use.
+
+## Listing Projects
+
+Use `nx show projects` to list projects in the workspace.
+
+```bash
+# List all projects
+nx show projects
+
+# Filter by pattern (glob)
+nx show projects --projects "apps/*"
+nx show projects --projects "shared-*"
+
+# Filter by project type
+nx show projects --type app
+nx show projects --type lib
+nx show projects --type e2e
+
+# Filter by target (projects that have a specific target)
+nx show projects --withTarget build
+nx show projects --withTarget e2e
+
+# Find affected projects (changed since base branch)
+nx show projects --affected
+nx show projects --affected --base=main
+nx show projects --affected --type app
+
+# Combine filters
+nx show projects --type lib --withTarget test
+nx show projects --affected --exclude="*-e2e"
+
+# Output as JSON
+nx show projects --json
+```
+
+## Project Configuration
+
+Use `nx show project <name> --json` to get the full resolved configuration for a project.
+
+**Important**: Do NOT read `project.json` directly - it only contains partial configuration. The `nx show project` command returns the full resolved config including inferred targets from plugins.
+
+You can read the full project schema at `node_modules/nx/schemas/project-schema.json` to understand nx project configuration options.
+
+```bash
+# Get full project configuration
+nx show project my-app --json
+
+# Extract specific parts from the JSON
+nx show project my-app --json | jq '.targets'
+nx show project my-app --json | jq '.targets.build'
+nx show project my-app --json | jq '.targets | keys'
+
+
+# Check project metadata
+nx show project my-app --json | jq '{name, root, sourceRoot, projectType, tags}'
+```
+
+## Target Information
+
+Targets define what tasks can be run on a project.
+
+```bash
+# List all targets for a project
+nx show project my-app --json | jq '.targets | keys'
+
+# Get full target configuration
+nx show project my-app --json | jq '.targets.build'
+
+# Check target executor/command
+nx show project my-app --json | jq '.targets.build.executor'
+nx show project my-app --json | jq '.targets.build.command'
+
+# View target options
+nx show project my-app --json | jq '.targets.build.options'
+
+# Check target inputs/outputs (for caching)
+nx show project my-app --json | jq '.targets.build.inputs'
+nx show project my-app --json | jq '.targets.build.outputs'
+
+# Find projects with a specific target
+nx show projects --withTarget serve
+nx show projects --withTarget e2e
+```
+
+## Workspace Configuration
+
+Read `nx.json` directly for workspace-level configuration.
+You can read the full project schema at `node_modules/nx/schemas/nx-schema.json` to understand nx project configuration options.
+
+```bash
+# Read the full nx.json
+cat nx.json
+
+# Or use jq for specific sections
+cat nx.json | jq '.targetDefaults'
+cat nx.json | jq '.namedInputs'
+cat nx.json | jq '.plugins'
+cat nx.json | jq '.generators'
+```
+
+Key nx.json sections:
+
+- `targetDefaults` - Default configuration applied to all targets of a given name
+- `namedInputs` - Reusable input definitions for caching
+- `plugins` - Nx plugins and their configuration
+- ...and much more, read the schema or nx.json for details
+
+## Affected Projects
+
+Find projects affected by changes in the current branch.
+
+```bash
+# Affected since base branch (auto-detected)
+nx show projects --affected
+
+# Affected with explicit base
+nx show projects --affected --base=main
+nx show projects --affected --base=origin/main
+
+# Affected between two commits
+nx show projects --affected --base=abc123 --head=def456
+
+# Affected apps only
+nx show projects --affected --type app
+
+# Affected excluding e2e projects
+nx show projects --affected --exclude="*-e2e"
+
+# Affected by uncommitted changes
+nx show projects --affected --uncommitted
+
+# Affected by untracked files
+nx show projects --affected --untracked
+```
+
+## Common Exploration Patterns
+
+### "What's in this workspace?"
+
+```bash
+nx show projects
+nx show projects --type app
+nx show projects --type lib
+```
+
+### "How do I build/test/lint project X?"
+
+```bash
+nx show project X --json | jq '.targets | keys'
+nx show project X --json | jq '.targets.build'
+```
+
+### "What depends on library Y?"
+
+```bash
+# Find projects that may depend on Y by searching for imports
+# (Nx doesn't have a direct "dependents" command via CLI)
+grep -r "from '@myorg/Y'" --include="*.ts" --include="*.tsx" apps/ libs/
+```
+
+### "What configuration options are available?"
+
+```bash
+cat node_modules/nx/schemas/nx-schema.json | jq '.properties | keys'
+cat node_modules/nx/schemas/project-schema.json | jq '.properties | keys'
+```
+
+### "Why is project X affected?"
+
+```bash
+# Check what files changed
+git diff --name-only main
+
+# See which project owns those files
+nx show project X --json | jq '.root'
+```

.github/workflows/banner-monitor.yml

@@ -0,0 +1,101 @@
+name: Banner Content Monitor
+
+on:
+  schedule:
+    - cron: '*/15 * * * *'
+  workflow_dispatch: # Allow manual trigger
+
+permissions: {}
+
+env:
+  BANNER_URL: ${{ vars.BANNER_URL }}
+
+jobs:
+  check-and-deploy:
+    if: ${{ github.repository_owner == 'nrwl' }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fetch banner content and compute hash
+        id: banner
+        run: |
+          if [ -z "$BANNER_URL" ]; then
+            echo "BANNER_URL is not set"
+            exit 1
+          fi
+
+          # Fetch content and compute hash
+          CONTENT_HASH=$(curl -sf "$BANNER_URL" | sha256sum | cut -d' ' -f1)
+
+          if [ -z "$CONTENT_HASH" ]; then
+            echo "Failed to fetch banner content"
+            exit 1
+          fi
+
+          echo "current_hash=$CONTENT_HASH" >> $GITHUB_OUTPUT
+          echo "Current banner hash: $CONTENT_HASH"
+
+      - name: Restore cached hash
+        id: cache
+        uses: actions/cache/restore@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
+        with:
+          path: .banner-hash
+          key: banner-content-hash-
+          restore-keys: |
+            banner-content-hash-
+
+      - name: Compare hashes
+        id: compare
+        run: |
+          CURRENT_HASH="${{ steps.banner.outputs.current_hash }}"
+
+          if [ -f .banner-hash ]; then
+            CACHED_HASH=$(cat .banner-hash)
+            echo "Cached hash: $CACHED_HASH"
+          else
+            CACHED_HASH=""
+            echo "No cached hash found"
+          fi
+
+          if [ "$CURRENT_HASH" != "$CACHED_HASH" ]; then
+            echo "changed=true" >> $GITHUB_OUTPUT
+            echo "Banner content has changed!"
+          else
+            echo "changed=false" >> $GITHUB_OUTPUT
+            echo "Banner content unchanged"
+          fi
+
+      - name: Setup Node
+        if: steps.compare.outputs.changed == 'true'
+        uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
+        with:
+          node-version: '24'
+
+      - name: Trigger Netlify deploys
+        if: steps.compare.outputs.changed == 'true'
+        env:
+          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+        run: |
+          npm install -g netlify-cli
+
+          echo "Triggering nx-docs deploy..."
+          netlify deploy --trigger --prod -s nx-docs
+
+          echo "Triggering nx-dev deploy..."
+          netlify deploy --trigger --prod -s nx-dev
+
+          echo "Triggering nrwl-blog deploy..."
+          netlify deploy --trigger --prod -s nrwl-blog
+
+          echo "All deploys triggered successfully"
+
+      - name: Save new hash to cache
+        if: steps.compare.outputs.changed == 'true'
+        run: |
+          echo "${{ steps.banner.outputs.current_hash }}" > .banner-hash
+
+      - name: Update cache
+        if: steps.compare.outputs.changed == 'true'
+        uses: actions/cache/save@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
+        with:
+          path: .banner-hash
+          key: banner-content-hash-${{ github.run_id }}

.github/workflows/ci.yml

@@ -13,11 +13,16 @@ env:
   NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}
   NX_CLOUD_ENABLE_METRICS_COLLECTION: 'true'
   PNPM_HOME: ~/.pnpm
+  # Pin corepack to the pnpm version from packageManager. Without this, corepack
+  # falls back to "latest" in directories that have no packageManager field
+  # (e.g. e2e temp dirs), pulling pnpm 11 and breaking install.
+  COREPACK_DEFAULT_TO_LATEST: '0'
 
 jobs:
   main-linux:
     runs-on: ubuntu-latest
     env:
+      NX_BATCH_MODE: 'true'
       NX_E2E_CI_CACHE_KEY: e2e-github-linux
       NX_DAEMON: 'true'
       NX_PERF_LOGGING: 'false'
@@ -27,8 +32,9 @@ jobs:
       NX_CI_EXECUTION_ENV: 'linux'
       NX_CLOUD_NO_TIMEOUTS: 'true'
       NX_ALLOW_NON_CACHEABLE_DTE: 'true'
-      NX_CLOUD_USE_NEW_TASK_APIS: 'true'
-      NX_CLOUD_USE_NEW_STREAM_OUTPUT: 'true'
+      NX_CLOUD_EXPERIMENTAL_POLLING: 'true'
+      NX_CLOUD_CONTINUOUS_ASSIGNMENT: 'false'
+      NX_CLOUD_VERBOSE_LOGGING: 'true'
 
     steps:
       - name: Checkout
@@ -37,25 +43,21 @@ jobs:
           fetch-depth: 0
           filter: tree:0
 
+      - name: Set verbose logging from debug mode
+        if: runner.debug == '1'
+        run: echo "NX_VERBOSE_LOGGING=true" >> "$GITHUB_ENV"
+
       - name: Fetch Master
         run: git fetch origin master:master
         if: ${{ github.event_name == 'pull_request' }}
 
       - name: Set SHAs
-        uses: nrwl/nx-set-shas@1859e66a83ac9be0dceecbd9a023702e27ac47f4 # v4.3.3
+        uses: nrwl/nx-set-shas@310288c04d90696f9f1bc27c5e3caea6642b53d4 # v5.0.0
         with:
           main-branch-name: 'master'
 
       - name: Start CI Run
-        run: npx nx-cloud@next start-ci-run --auto-apply-fixes="*format:check*,*sync:check*,*conformance:check*,*format-native*,*lint-native*,*lint*,*astro-docs:validate-links*" --distribute-on="./.nx/workflows/dynamic-changesets.yaml" --stop-agents-after="e2e"
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ca-certificates lsof libvips-dev libglib2.0-dev libgirepository1.0-dev
-
-      - name: Install Chrome
-        uses: browser-actions/setup-chrome@2dbff04819ebbfd5c974947148805a825b8a07fd # v2.1.0
+        run: npx nx-cloud@next start-ci-run --distribute-on="./.nx/workflows/dynamic-changesets.yaml" --stop-agents-after="e2e"
 
       - name: Setup dev tools with mise
         uses: jdx/mise-action@146a28175021df8ca24f8ee1828cc2a60f980bd5 # v3
@@ -65,35 +67,48 @@ jobs:
           corepack enable
           corepack prepare --activate
 
+      - name: Get pnpm store directory
+        id: pnpm-cache
+        run: echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - name: Cache pnpm store
+        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
+        with:
+          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@48b5f213c81028ace310571dc5ec0fbbca0b2947 # v4.4.3
 
       - name: Install project dependencies
-        run: |
-          pnpm install --frozen-lockfile
-          pnpm playwright install --with-deps
+        run: pnpm install --frozen-lockfile
+
+      - name: Restore .NET analyzer projects
+        run: dotnet restore nx.sln
 
       - name: Nx Report
-        run: 
+        run:
           pnpm nx report
 
       - name: Run Checks/Lint/Test/Build
         run: |
           pids=()
 
-          pnpm nx-cloud record -- nx format:check &
+          pnpm nx record -- nx format:check &
           pids+=($!)
 
-          pnpm nx-cloud record -- nx sync:check
+          pnpm nx record -- nx sync:check
           pids+=($!)
 
-          pnpm nx-cloud record -- nx-cloud conformance:check
+          pnpm nx build workspace-plugin && pnpm nx record -- pnpm nx-cloud conformance:check
           pids+=($!)
 
           pnpm nx run-many -t check-imports check-lock-files check-codeowners --parallel=1 --no-dte &
           pids+=($!)
 
-          pnpm nx affected --targets=lint,test,test-kt,build,e2e,e2e-ci,format-native,lint-native &
+          pnpm nx affected --targets=lint,test,build,e2e,e2e-ci,format-native,lint-native,gradle:build-ci,vale,run &
           pids+=($!)
 
           for pid in "${pids[@]}"; do
@@ -101,7 +116,7 @@ jobs:
           done
         timeout-minutes: 100
       - name: Fix CI
-        run: pnpm nx-cloud fix-ci
+        run: pnpm nx fix-ci
         if: failure()
 
   main-macos:
@@ -131,6 +146,10 @@ jobs:
           fetch-depth: 0
           filter: tree:0
 
+      - name: Set verbose logging from debug mode
+        if: runner.debug == '1'
+        run: echo "NX_VERBOSE_LOGGING=true" >> "$GITHUB_ENV"
+
       - name: Fetch Master
         run: git fetch origin master:master
         if: ${{ github.event_name == 'pull_request' }}
@@ -144,7 +163,7 @@ jobs:
           corepack prepare --activate
 
       - name: Set SHAs
-        uses: nrwl/nx-set-shas@1859e66a83ac9be0dceecbd9a023702e27ac47f4 # v4.3.3
+        uses: nrwl/nx-set-shas@310288c04d90696f9f1bc27c5e3caea6642b53d4 # v5.0.0
         with:
           main-branch-name: 'master'
 
@@ -277,12 +296,30 @@ jobs:
             ~/Library/Caches/Homebrew
           key: nrwl-nx-homebrew-packages
 
+      - name: Get pnpm store directory
+        if: steps.check-changes.outputs.has_changes == 'true'
+        id: pnpm-cache-macos
+        run: echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
+
+      - name: Cache pnpm store
+        if: steps.check-changes.outputs.has_changes == 'true'
+        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
+        with:
+          path: ${{ steps.pnpm-cache-macos.outputs.STORE_PATH }}
+          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
+          restore-keys: |
+            ${{ runner.os }}-pnpm-store-
+
       - name: Install project dependencies
         if: steps.check-changes.outputs.has_changes == 'true'
         run: |
           pnpm install --frozen-lockfile
           pnpm playwright install --with-deps
 
+      - name: Restore .NET packages
+        if: steps.check-changes.outputs.has_changes == 'true'
+        run: dotnet restore nx.sln
+
       - name: Run E2E Tests for macOS
         if: steps.check-changes.outputs.has_changes == 'true'
         run: |

.github/workflows/e2e-matrix.yml

@@ -13,6 +13,10 @@ on:
 
 env:
   CYPRESS_CACHE_FOLDER: ${{ github.workspace }}/.cypress
+  # Pin corepack to the pnpm version from packageManager. Without this, corepack
+  # falls back to "latest" in directories that have no packageManager field
+  # (e.g. e2e temp dirs), pulling pnpm 11 and breaking install.
+  COREPACK_DEFAULT_TO_LATEST: '0'
 
 permissions: {}
 jobs:
@@ -30,19 +34,14 @@ jobs:
           # - windows-latest Windows fails to build gradle wrapper which always runs when we build nx.
           ## https://staging.nx.app/runs/LgD4vxGn8w?utm_source=pull-request&utm_medium=comment
         node_version:
-          # TODO(v23): remove node 20 - EOL April 2026
-          - 20
           - 22
           - 24
+          - 26
         exclude:
-          # run just node v24 on macos and windows
-          - os: macos-latest
-            node_version: 20
+          # macos skips the oldest node to keep the macos matrix slim
           - os: macos-latest
             node_version: 22
           # - os: windows-latest TODO(Jack): Windows fails to build gradle wrapper which always runs when we build nx. Re-enable when we fix this.
-          #   node_version: 20
-          # - os: windows-latest TODO (Jack): Windows fails to build gradle wrapper which always runs when we build nx. Re-enable when we fix this.
           #   node_version: 22
 
     name: Cache install (${{ matrix.os }}, node v${{ matrix.node_version }})
@@ -79,10 +78,14 @@ jobs:
         id: brew-install-python-setuptools
         run: brew install python-setuptools
 
-      - name: Install packages
-        run: |
-          pnpm install --frozen-lockfile
-          pnpm playwright install --with-deps
+      - name: Install pnpm packages
+        run: pnpm install --frozen-lockfile
+
+      - name: Install Playwright
+        run: pnpm playwright install --with-deps
+
+      - name: Restore .NET packages
+        run: dotnet restore nx.sln
 
       - name: Homebrew cache directory path
         if: ${{ matrix.os == 'macos-latest' }}
@@ -164,10 +167,14 @@ jobs:
           corepack enable
           corepack prepare --activate
 
-      - name: Install packages
-        run: |
-          pnpm install --frozen-lockfile
-          pnpm playwright install --with-deps
+      - name: Install pnpm packages
+        run: pnpm install --frozen-lockfile
+
+      - name: Install Playwright
+        run: pnpm playwright install --with-deps
+
+      - name: Restore .NET packages
+        run: dotnet restore nx.sln
 
       - name: Cleanup
         if: ${{ matrix.os == 'ubuntu-latest' }}
@@ -327,7 +334,7 @@ jobs:
           NX_NATIVE_LOGGING: 'false'
           NX_E2E_RUN_E2E: 'true'
           NX_CLOUD_NO_TIMEOUTS: 'true'
-          NX_E2E_SKIP_CLEANUP: 'true'
+          NX_E2E_SKIP_GLOBAL_CLEANUP: 'true'
           NODE_OPTIONS: --max_old_space_size=8192
           SELECTED_PM: ${{ matrix.package_manager }}
           npm_config_registry: http://localhost:4872
@@ -352,7 +359,7 @@ jobs:
           NX_E2E_VERBOSE_LOGGING: 'true'
           NX_NATIVE_LOGGING: 'false'
           NX_E2E_RUN_E2E: 'true'
-          NX_E2E_SKIP_CLEANUP: 'true'
+          NX_E2E_SKIP_GLOBAL_CLEANUP: 'true'
           NODE_OPTIONS: --max_old_space_size=8192
           SELECTED_PM: 'npm'
           npm_config_registry: http://localhost:4872
@@ -397,7 +404,7 @@ jobs:
     if: ${{ always() && github.repository_owner == 'nrwl' && github.event_name != 'workflow_dispatch' }}
     runs-on: ubuntu-latest
     needs: e2e
-    timeout-minutes: 10
+    timeout-minutes: 15
     outputs:
       message: ${{ steps.process-json.outputs.slack_message }}
       proj_duration: ${{ steps.process-json.outputs.slack_proj_duration }}
@@ -425,8 +432,10 @@ jobs:
           combined=$(jq -sc . outputs/*/matrix.json)
           echo "combined=$combined" >> $GITHUB_OUTPUT
 
-      - name: Process results with TypeScript script
+      - name: Process results and collect failure details
         id: process-json
+        env:
+          GH_TOKEN: ${{ github.token }}
         run: |
           echo '${{ steps.combine-json.outputs.combined }}' | npx tsx .github/workflows/nightly/process-result.ts
 

.github/workflows/generate-embeddings.yml

@@ -26,7 +26,7 @@ jobs:
         uses: pnpm/action-setup@7088e561eb65bb68695d245aa206f005ef30921d # v4.1.0
         id: pnpm-install
         with:
-          version: 10.11.1
+          version: 11.2.2
           run_install: false
 
       - name: Get pnpm store directory

.github/workflows/issue-notifier.yml

@@ -20,7 +20,7 @@ jobs:
 
       - uses: pnpm/action-setup@7088e561eb65bb68695d245aa206f005ef30921d # v4.1.0
         with:
-          version: 10.11.1
+          version: 11.2.2
 
       - name: Use Node.js ${{ matrix.node_version }}
         uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0
@@ -64,7 +64,6 @@ jobs:
         id: slack
         uses: slackapi/slack-github-action@91efab103c0de0a537f72a35f6b8cda0ee76bf0a # v2.1.1
         with:
+          webhook: ${{ secrets.SLACK_ISSUES_REPORT_URL }}
+          webhook-type: incoming-webhook
           payload: ${{ steps.collect.outputs.SLACK_MESSAGE }}
-        env:
-          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_ISSUES_REPORT_URL }}
-          SLACK_WEBHOOK_TYPE: INCOMING_WEBHOOK

.github/workflows/lock-threads.yml

@@ -17,9 +17,10 @@ jobs:
     if: ${{ github.repository_owner == 'nrwl' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: dessant/lock-threads@7de207be1d3ce97a9abe6ff1306222982d1ca9f9 # v5.0.1
+      - uses: dessant/lock-threads@6548363a2d763e3a4a3a0dc04ca4a10481d8e536 # v6.0.0
         id: lockthreads
         with:
+          process-only: 'issues, prs'
           github-token: ${{ github.token }}
           issue-inactive-days: "30" # Lock issues after 30 days of being closed
           pr-inactive-days: "5" # Lock closed PRs after 5 days. This ensures that issues that stem from a PR are opened as issues, rather than comments on the recently merged PR.

.github/workflows/nightly/analyze-failures.ts

@@ -0,0 +1,415 @@
+import { exec } from 'child_process';
+import { execSync } from 'child_process';
+
+const MAX_CONCURRENCY = 8;
+
+interface MatrixResult {
+  project: string;
+  codeowners: string;
+  node_version: number | string;
+  package_manager: string;
+  os: string;
+  os_name: string;
+  os_timeout: number;
+  is_golden?: boolean;
+  status: 'success' | 'failure' | 'cancelled';
+  duration: number;
+}
+
+const REPO = process.env.GITHUB_REPOSITORY || 'nrwl/nx';
+const RUN_ID = process.env.GITHUB_RUN_ID || '0';
+
+function gh(args: string): string {
+  try {
+    return execSync(`gh ${args}`, {
+      encoding: 'utf-8',
+      timeout: 60_000,
+      maxBuffer: 10 * 1024 * 1024,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function ghAsync(args: string): Promise<string> {
+  return new Promise((resolve) => {
+    exec(
+      `gh ${args}`,
+      { encoding: 'utf-8', timeout: 60_000, maxBuffer: 10 * 1024 * 1024 },
+      (err, stdout) => resolve(err ? '' : (stdout || '').trim())
+    );
+  });
+}
+
+async function ghParallel<T>(
+  items: T[],
+  fn: (item: T) => string,
+  concurrency = MAX_CONCURRENCY
+): Promise<Map<T, string>> {
+  const results = new Map<T, string>();
+  const queue = [...items];
+
+  async function worker() {
+    while (queue.length > 0) {
+      const item = queue.shift()!;
+      results.set(item, await ghAsync(fn(item)));
+    }
+  }
+
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, items.length) }, () => worker())
+  );
+  return results;
+}
+
+function extractJestBlocks(raw: string): string {
+  const lines = raw
+    .replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z /gm, '')
+    .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+    .split('\n');
+
+  const blocks: string[] = [];
+  let capturing = false;
+  for (const line of lines) {
+    if (line.startsWith(' FAIL ')) capturing = true;
+    if (capturing) blocks.push(line);
+    if (line.startsWith('Ran all test suites')) capturing = false;
+  }
+  return blocks.slice(0, 50).join('\n');
+}
+
+function extractTestFiles(block: string): string[] {
+  const matches = block.match(/FAIL\s+\S+\s+(src\/[^\s]+\.test\.ts)/g) || [];
+  return [...new Set(matches.map((m) => m.replace(/FAIL\s+\S+\s+/, '')))];
+}
+
+// Extract a normalized error signature for a test file from a Jest block.
+// Used to distinguish different root causes for the same test file across runs.
+function extractErrorSignature(block: string, testFile: string): string {
+  const lines = block.split('\n');
+  let afterBullet = false;
+  let inFile = false;
+  for (const l of lines) {
+    if (l.includes('FAIL') && l.includes(testFile)) { inFile = true; continue; }
+    if (inFile && /●/.test(l)) { afterBullet = true; continue; }
+    if (!inFile || !afterBullet) continue;
+    const trimmed = l.trim();
+    if (!trimmed) continue;
+    // Skip generic "Command failed" and warnings — find the actual error
+    if (/^Command failed:|^warning /i.test(trimmed)) continue;
+    // Normalize dynamic parts
+    return trimmed
+      .replace(/\/tmp\/[^\s]+/g, '<tmpdir>')
+      .replace(/\/Users\/[^\s]+/g, '<path>')
+      .replace(/\/home\/[^\s]+/g, '<path>')
+      .replace(/[a-z]+\d{5,}/gi, '<id>')
+      .replace(/\d{4}-\d{2}-\d{2}T[\d:._Z-]+/g, '<ts>')
+      .replace(/\d+\.\d+\.\d+/g, '<ver>')
+      .trim();
+  }
+  return '';
+}
+
+// Extract signatures for all test files in a block
+function extractSignatures(
+  block: string,
+  testFiles: string[]
+): Map<string, string> {
+  const sigs = new Map<string, string>();
+  for (const tf of testFiles) {
+    sigs.set(tf, extractErrorSignature(block, tf));
+  }
+  return sigs;
+}
+
+function extractBlockForFile(fullBlock: string, testFile: string): string {
+  const lines = fullBlock.split('\n');
+  const result: string[] = [];
+  let capturing = false;
+  for (const line of lines) {
+    if (line.includes('FAIL') && line.includes(testFile)) capturing = true;
+    else if (capturing && line.match(/^ FAIL /)) capturing = false;
+    if (capturing) result.push(line);
+  }
+  return result.slice(0, 20).join('\n');
+}
+
+export interface JobLink {
+  combo: string;
+  url: string;
+}
+
+export interface FailureDetailsResult {
+  report: string;
+  goldenJobLinks: Map<string, JobLink[]>; // project -> [{combo, url}]
+}
+
+/**
+ * Collects detailed failure information for golden projects.
+ * Called by process-result.ts when golden failures exist.
+ * Returns Slack mrkdwn report + job links for the summary section.
+ */
+export async function collectFailureDetails(
+  combined: MatrixResult[],
+  failedGoldenProjectNames: string[]
+): Promise<FailureDetailsResult> {
+  const projectNames = failedGoldenProjectNames;
+  if (projectNames.length === 0) {
+    return { report: '', goldenJobLinks: new Map() };
+  }
+
+  // Group failures by project for combo info
+  const failuresByProject = new Map<string, MatrixResult[]>();
+  for (const r of combined) {
+    if (r.is_golden && (r.status === 'failure' || r.status === 'cancelled')) {
+      if (!failuresByProject.has(r.project))
+        failuresByProject.set(r.project, []);
+      failuresByProject.get(r.project)!.push(r);
+    }
+  }
+
+  // Step 1: Fetch failure logs (one per OS/PM combo per project)
+  const failedJobsRaw = gh(
+    `run view ${RUN_ID} --repo ${REPO} --json jobs --jq '[.jobs[] | select(.conclusion == "failure") | {id: .databaseId, name: .name, project: (.name | split(" ") | last), combo: (.name | split(" ")[0])}]'`
+  );
+  const failedJobs: Array<{
+    id: number;
+    name: string;
+    project: string;
+    combo: string;
+  }> = failedJobsRaw ? JSON.parse(failedJobsRaw) : [];
+
+  const jobsToFetch: Array<{ id: number; project: string }> = [];
+  for (const project of projectNames) {
+    const seen = new Set<string>();
+    for (const job of failedJobs.filter((j) => j.project === project)) {
+      const key = job.combo.split('/').slice(0, 2).join('/');
+      if (!seen.has(key)) {
+        seen.add(key);
+        jobsToFetch.push({ id: job.id, project: job.project });
+      }
+    }
+  }
+
+  const logResults = await ghParallel(
+    jobsToFetch,
+    (job) => `api repos/${REPO}/actions/jobs/${job.id}/logs`
+  );
+
+  // Keep per-combo logs separate AND a merged block per project
+  interface ComboLog {
+    combo: string;
+    block: string;
+    testFiles: string[];
+    signatures: Map<string, string>; // testFile -> error signature
+  }
+  const projectComboLogs = new Map<string, ComboLog[]>();
+  const projectLogs = new Map<string, string>(); // merged block for backwards compat
+
+  for (const [job, raw] of logResults) {
+    if (!raw) continue;
+    const cleaned = raw
+      .replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z /gm, '')
+      .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '');
+    const block = extractJestBlocks(raw);
+    const testFiles = extractTestFiles(cleaned);
+    const sigs = extractSignatures(cleaned, testFiles);
+    const combo =
+      failedJobs.find((j) => j.id === job.id)?.combo || 'unknown';
+
+    if (!projectComboLogs.has(job.project))
+      projectComboLogs.set(job.project, []);
+    projectComboLogs.get(job.project)!.push({
+      combo,
+      block,
+      testFiles,
+      signatures: sigs,
+    });
+
+    projectLogs.set(
+      job.project,
+      (projectLogs.get(job.project) || '') + '\n' + block
+    );
+  }
+
+  // Step 2: Build distinct failures per project — each (testFile, signature, combos) is a "failure"
+  interface DistinctFailure {
+    testFile: string;
+    signature: string;
+    combos: string[];
+    block: string; // the Jest block from the first combo that has this signature
+  }
+
+  const projectDistinctFailures = new Map<string, DistinctFailure[]>();
+  for (const project of projectNames) {
+    const comboLogs = projectComboLogs.get(project) || [];
+    const seen = new Map<string, DistinctFailure>(); // "testFile|signature" -> failure
+
+    for (const cl of comboLogs) {
+      for (const tf of cl.testFiles) {
+        const sig = cl.signatures.get(tf) || '';
+        const key = `${tf}|${sig}`;
+        if (seen.has(key)) {
+          seen.get(key)!.combos.push(cl.combo);
+        } else {
+          seen.set(key, {
+            testFile: tf,
+            signature: sig,
+            combos: [cl.combo],
+            block: extractBlockForFile(cl.block, tf),
+          });
+        }
+      }
+    }
+    projectDistinctFailures.set(project, [...seen.values()]);
+  }
+
+  // Step 3: Format report
+  const lines: string[] = ['', '🔍 *Failure Details*', ''];
+
+  const sorted = [...projectNames].sort(
+    (a, b) =>
+      (failuresByProject.get(b)?.length || 0) -
+        (failuresByProject.get(a)?.length || 0) || a.localeCompare(b)
+  );
+
+  for (const project of sorted) {
+    const projResults = failuresByProject.get(project) || [];
+    const distinctFailures = projectDistinctFailures.get(project) || [];
+    const block = projectLogs.get(project) || '';
+
+    const pms = [...new Set(projResults.map((r) => r.package_manager))];
+    const pattern =
+      pms.length === 1
+        ? `${pms[0]}-only`
+        : pms.length >= 3
+          ? 'all PMs'
+          : pms.join('+');
+
+    const uniqueCombos = [
+      ...new Set(
+        failedJobs.filter((j) => j.project === project).map((j) => j.combo)
+      ),
+    ];
+
+    lines.push('———————————————————————————');
+    lines.push(`*${project}* — ${projResults.length} combos (${pattern})`);
+    lines.push('');
+
+    if (distinctFailures.length > 0) {
+      for (const failure of distinctFailures) {
+        const comboStr = failure.combos.join(', ');
+        lines.push(`📋 \`${failure.testFile}\` (${comboStr})`);
+
+        if (failure.block) {
+          lines.push('```');
+          lines.push(failure.block);
+          lines.push('```');
+        }
+      }
+
+      const summaryMatch = block.match(/^Test Suites:.*$/m);
+      if (summaryMatch) lines.push(`_${summaryMatch[0]}_`);
+    } else {
+      // No Jest blocks — find which step failed and extract its error output
+      const firstJob = failedJobs.find((j) => j.project === project);
+      if (firstJob) {
+        // Get the failed step name from the jobs API
+        const stepsRaw = gh(
+          `run view ${RUN_ID} --repo ${REPO} --json jobs --jq '[.jobs[] | select(.databaseId == ${firstJob.id})][0].steps[] | select(.conclusion == "failure") | .name'`
+        );
+        const failedStep = stepsRaw || 'unknown step';
+
+        // Get the log and extract error lines
+        const raw = gh(`api repos/${REPO}/actions/jobs/${firstJob.id}/logs`);
+        const cleaned = raw
+          .split('\n')
+          .map((l) => l.replace(/^\d{4}-\d{2}-\d{2}T[\d:.]+Z /, ''))
+          .map((l) => l.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, ''));
+
+        // Extract the failed Nx task output block (❌ > nx run <task> ... until next ##[group] or NX summary)
+        const failedTaskBlock: string[] = [];
+        let capturingTask = false;
+        for (const l of cleaned) {
+          if (/❌.*> nx run /i.test(l)) {
+            capturingTask = true;
+            failedTaskBlock.push(l);
+            continue;
+          }
+          if (capturingTask) {
+            if (/^##\[group\]|NX.*Running target/i.test(l) || failedTaskBlock.length >= 15) {
+              capturingTask = false;
+            } else {
+              failedTaskBlock.push(l);
+            }
+          }
+        }
+
+        // Extract the Nx failure summary block ("Running target...failed" + "Failed tasks:" + task list)
+        const nxFailureBlock: string[] = [];
+        let capturingNx = false;
+        for (const l of cleaned) {
+          if (/NX.*Running target.*failed/i.test(l)) capturingNx = true;
+          if (capturingNx) {
+            nxFailureBlock.push(l);
+            if (/^Hint:/i.test(l.trim()) || nxFailureBlock.length >= 10) {
+              capturingNx = false;
+            }
+          }
+        }
+
+        // Fallback: if no Nx blocks or task blocks found, extract generic error lines
+        let fallbackErrors: string[] = [];
+        if (nxFailureBlock.length === 0 && failedTaskBlock.length === 0) {
+          fallbackErrors = cleaned.filter((l) => {
+            const t = l.trim();
+            if (t.length < 10) return false;
+            if (/warning|warn\b|deprecated|orphan|Node\.js 20|FORCE_JAVASCRIPT|\* \[new branch\]|\* \[new tag\]/i.test(t)) return false;
+            return (
+              /error TS\d+:|^Error:|^\s*error\b[:\s]|ERR!|ERESOLVE|##\[error\]/i.test(t) ||
+              /Cannot find module|ENOENT|EACCES|permission denied/i.test(t) ||
+              /Segmentation fault|killed|OOM|out of memory/i.test(t) ||
+              /command not found|No such file or directory/i.test(t) ||
+              /Process completed with exit code [^0]/i.test(t)
+            );
+          }).slice(0, 5);
+        }
+
+        // Combine: Nx summary first, then task output, then fallback errors
+        const relevantErrors = [
+          ...nxFailureBlock,
+          ...(failedTaskBlock.length > 0 ? ['', ...failedTaskBlock] : []),
+          ...(fallbackErrors.length > 0 ? ['', ...fallbackErrors] : []),
+        ];
+
+        lines.push(`⚠️ Tests did not run — failed at step: *${failedStep}*`);
+        if (relevantErrors.length > 0) {
+          lines.push('```');
+          lines.push(relevantErrors.join('\n'));
+          lines.push('```');
+        }
+        lines.push(`Failing combos: ${uniqueCombos.join(', ')}`);
+      } else {
+        lines.push('⏱️ No job data available');
+      }
+    }
+    lines.push('');
+  }
+
+  // Build job links for the summary section
+  const runUrl = `https://github.com/${REPO}/actions/runs/${RUN_ID}`;
+  const goldenJobLinks = new Map<string, JobLink[]>();
+  for (const project of projectNames) {
+    const projectJobs = failedJobs.filter((j) => j.project === project);
+    goldenJobLinks.set(
+      project,
+      projectJobs.map((j) => ({
+        combo: j.combo,
+        url: `${runUrl}/job/${j.id}`,
+      }))
+    );
+  }
+
+  return { report: lines.join('\n'), goldenJobLinks };
+}

.github/workflows/nightly/process-matrix.ts

@@ -16,7 +16,7 @@ type MatrixDataOS = {
 type MatrixData = {
   coreProjects: MatrixDataProject[],
   projects: MatrixDataProject[],
-  nodeTLS: number,
+  lowestNodeLTS: number,
   setup: MatrixDataOS[],
 }
 
@@ -67,20 +67,25 @@ const matrixData: MatrixData = {
     { name: 'e2e-storybook', codeowners: 'S04SVQ8H0G5' },
     { name: 'e2e-nuxt', codeowners: 'S04SJ6PL98X' }
   ],
-  // TODO(v23): remove node 20 - EOL April 2026
-  nodeTLS: 20,
+  // Non-core plugins only run on the lowest LTS. Plugin-level changes are
+  // less Node-version-sensitive than core, so single-version coverage is enough.
+  lowestNodeLTS: 22,
   setup: [
     {
       os: 'ubuntu-latest',
       os_name: 'Linux',
       os_timeout: 60,
       package_managers: ['npm', 'pnpm', 'yarn'],
-      node_versions: ['20.19.0', '22.12.0', '24.0.0'],
+      // TODO: re-add '26.0.0' once playwright ships the yauzl fix for node 26 extract hang.
+      // See https://github.com/microsoft/playwright/issues/40724
+      node_versions: ['22.13.0', '24.0.0'],
       excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo']
     },
     // Docker is not supported on ARM-based macOS runners (no nested virtualization)
     // See: https://github.com/docker/setup-docker-action and https://github.com/douglascamata/setup-docker-macos-action
     // We may want to look into adding intel only for this docker case, at least until vm-in-vm works on latest macos
+    // TODO: re-add '26.0.0' once playwright ships the yauzl fix for node 26 extract hang.
+    // See https://github.com/microsoft/playwright/issues/40724
     { os: 'macos-latest', os_name: 'MacOS', os_timeout: 90, package_managers: ['npm'], node_versions: ['24.0.0'], excluded: ['e2e-docker'] }
     // TODO (Jack): Fix Windows support as gradle fails when running nx build https://staging.nx.app/runs/LgD4vxGn8w?utm_source=pull-request&utm_medium=comment
     // { os: 'windows-latest', os_name: 'WinOS', os_timeout: 180, package_managers: ['npm'], node_versions: ['24.0.0'], excluded: ['e2e-detox', 'e2e-react-native', 'e2e-expo'] }
@@ -124,7 +129,7 @@ for (let p = 0; p < matrixData.coreProjects.length; p++) {
 }
 // process other projects
 for (let p = 0; p < matrixData.projects.length; p++) {
-  processProject(matrixData.projects[p], matrixData.nodeTLS);
+  processProject(matrixData.projects[p], matrixData.lowestNodeLTS);
 }
 
 if (matrix.length > 256) {

.github/workflows/nightly/process-result.ts

@@ -1,5 +1,6 @@
 import * as fs from 'fs';
 import { MatrixItem } from './process-matrix';
+import { collectFailureDetails, JobLink } from './analyze-failures';
 
 interface MatrixResult extends MatrixItem {
   status: 'success' | 'failure' | 'cancelled';
@@ -52,42 +53,31 @@ function processResults(combined: MatrixResult[]): ProcessedResults {
   const otherFailingCount = uniqueFailedOtherProjects.size;
 
   result += `\n🌟 *Golden Projects*`;
-  result += `\n✅ Passing: ${goldenPassingCount}`;
-  result += `\n❌ Failing: ${goldenFailingCount}`;
+  result += `\n✅ Passing: ${goldenPassingCount} | ❌ Failing: ${goldenFailingCount}`;
 
   if (failedGoldenProjects.length > 0) {
-    result += `\n\n🚨 *Failed Golden Projects*\n\`\`\``;
-    result += `\n| Failed project                 |`;
-    result += `\n|--------------------------------|`;
-    let lastProject: string | undefined;
+    result += `\n\n🚨 *Failed Golden Projects*`;
+    // Project names listed here — combo links added later by main() with job data
+    const seenProjects = new Set<string>();
     failedGoldenProjects.forEach(matrix => {
-      const project = matrix.project !== lastProject ? matrix.project : '';
-      if (project) {
-        result += `\n| ${project.padEnd(30)} |`;
-        lastProject = matrix.project;
+      if (!seenProjects.has(matrix.project)) {
+        seenProjects.add(matrix.project);
+        result += `\n\n*${matrix.project}*`;
+        // Placeholder — main() will replace with linked combos
+        result += `\n  {{COMBOS:${matrix.project}}}`;
       }
     });
-    result += `\n\`\`\``;
   }
 
-  result += `\n\n🔧 *Other Projects*`;
-  result += `\n✅ Passing: ${otherPassingCount}`;
-  result += `\n❌ Failing: ${otherFailingCount}`;
-
-  // Failed Other Projects Table (if any)
-  if (failedRegularProjects.length > 0) {
-    result += `\n\n⚠️ *Failed Other Projects*\n\`\`\``;
-    result += `\n| Failed project                 |`;
-    result += `\n|--------------------------------|`;
-    let lastProject: string | undefined;
-    failedRegularProjects.forEach(matrix => {
-      const project = matrix.project !== lastProject ? matrix.project : '';
-      if (project) {
-        result += `\n| ${project.padEnd(30)} |`;
-        lastProject = matrix.project;
-      }
+  if (otherFailingCount > 0) {
+    const otherProjectCounts = new Map<string, number>();
+    failedRegularProjects.forEach(m => {
+      otherProjectCounts.set(m.project, (otherProjectCounts.get(m.project) || 0) + 1);
     });
-    result += `\n\`\`\``;
+    const otherSummary = [...otherProjectCounts.entries()]
+      .map(([p, c]) => `${p} (${c})`)
+      .join(', ');
+    result += `\n\n⚠️ *Failed Other Projects:* ${otherSummary}`;
   }
 
   if (failedProjects.length === 0) {
@@ -180,7 +170,7 @@ function setOutput(key: string, value: string) {
   }
 }
 
-try {
+async function main() {
   const combinedInput = process.argv[2]
     ? process.argv[2]
     : fs.readFileSync(0, 'utf-8').trim();
@@ -188,10 +178,52 @@ try {
   const combined: MatrixResult[] = JSON.parse(combinedInput);
   const results = processResults(combined);
 
+  // Collect detailed failure info if golden failures exist
+  if (results.has_golden_failures === 'true') {
+    try {
+      const failedProjects = [
+        ...new Set(
+          combined
+            .filter((c) => c.is_golden && (c.status === 'failure' || c.status === 'cancelled'))
+            .map((c) => c.project)
+        ),
+      ];
+      const { report, goldenJobLinks } = await collectFailureDetails(combined, failedProjects);
+
+      // Replace combo placeholders in the summary with linked combos
+      for (const [project, links] of goldenJobLinks) {
+        const placeholder = `{{COMBOS:${project}}}`;
+        const linkedCombos =
+          links.length > 0
+            ? links.map((l) => `  · <${l.url}|${l.combo}>`).join('\n')
+            : '  (no job data)';
+        results.slack_message = results.slack_message.replace(
+          placeholder,
+          linkedCombos
+        );
+      }
+
+      // Remove any unreplaced placeholders (if collectFailureDetails didn't have data for a project)
+      results.slack_message = results.slack_message.replace(
+        /  \{\{COMBOS:[^}]+\}\}/g,
+        '  (no job data)'
+      );
+
+      if (report) {
+        results.slack_message += '\n\n' + report;
+      }
+    } catch (e) {
+      console.error('Failed to collect failure details (brief report will still be posted):', e);
+      results.slack_message += '\n\n⚠️ _Failed to collect detailed failure information_';
+    }
+  }
+
   Object.entries(results).forEach(([key, value]) => {
     setOutput(key, value);
   });
-} catch (error) {
+}
+
+main().catch((error) => {
   console.error('Error processing results:', error);
   process.exit(1);
-}
+});

.github/workflows/npm-audit.yml

@@ -18,7 +18,7 @@ jobs:
 
       - uses: pnpm/action-setup@7088e561eb65bb68695d245aa206f005ef30921d # v4.1.0
         with:
-          version: 10.11.1 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
+          version: 11.2.2 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
 
       - name: Run a security audit
         run: pnpm dlx audit-ci --critical --report-type summary

.github/workflows/publish.yml

@@ -21,8 +21,9 @@ env:
   DEBUG: napi:*
   NX_RUN_GROUP: ${{ github.run_id }}-${{ github.run_attempt }}
   CYPRESS_INSTALL_BINARY: 0
-  NODE_VERSION: 22.16.0
-  PNPM_VERSION: 10.11.1 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
+  NODE_VERSION: 26.3.0
+  PNPM_VERSION: 11.2.2 # Aligned with root package.json (pnpm/action-setup will helpfully error if out of sync)
+  NX_GRADLE_PROJECT_GRAPH_TIMEOUT: 600
 
 jobs:
   # We first need to determine the version we are releasing, and if we need a custom repo or ref to use for the git checkout in subsequent steps.
@@ -129,6 +130,7 @@ jobs:
           - host: windows-latest
             setup: |-
               choco install openjdk --version=21.0.0 -y
+              choco install dotnet-9.0-sdk -y
               rustup target add aarch64-pc-windows-msvc
             build: |
               export JAVA_HOME="C:\Program Files\OpenJDK\jdk-21"
@@ -147,22 +149,23 @@ jobs:
             build: |
               set -e
               apt-get update
+              apt-get install -y curl ca-certificates git xz-utils gpg
 
-              # Install Java 21
-              apt-get install -y openjdk-21-jdk
-              export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
-              export PATH="$JAVA_HOME/bin:$PATH"
-              java --version
+              # Install mise from the signed apt repo
+              install -dm 755 /etc/apt/keyrings
+              curl -fsSL https://mise.jdx.dev/gpg-key.pub | gpg --dearmor -o /etc/apt/keyrings/mise-archive-keyring.gpg
+              echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=$(dpkg --print-architecture)] https://mise.jdx.dev/deb stable main" > /etc/apt/sources.list.d/mise.list
+              apt-get update
+              apt-get install -y mise
 
-              curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
-              apt-get install -y nodejs=22.16.0-1nodesource1
+              # Provision Node, Java, .NET, Maven, corepack from mise.toml
+              cd /build
+              mise trust mise.toml
+              mise install
+              eval "$(mise env -s bash)"
 
-              export PATH="/usr/local/bin:$PATH"
-              node --version
-              npm --version
-
-              npm i -g pnpm@${PNPM_VERSION} --force
-              pnpm --version
+              corepack enable
+              corepack prepare --activate
 
               pnpm install --frozen-lockfile
               rustup target add x86_64-unknown-linux-gnu
@@ -173,28 +176,32 @@ jobs:
             build: |
               bash -c "
                 set -e
+                # mise's core node/java backends don't ship musl binaries and fall back to
+                # compile-from-source on Alpine, which fails. Install via apk + tarball instead.
                 echo 'https://dl-cdn.alpinelinux.org/alpine/edge/community' >> /etc/apk/repositories
-                apk add --no-cache curl xz openjdk21
+                apk add --no-cache curl xz openjdk21 build-base lld dotnet9-sdk
 
-                # Set up Java 21
+                # Java 21
                 export JAVA_HOME=/usr/lib/jvm/java-21-openjdk
                 export PATH=\"\$JAVA_HOME/bin:\$PATH\"
                 java --version
 
-                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v22.16.0/node-v22.16.0-linux-x64-musl.tar.xz -o node.tar.xz
+                # .NET 9 SDK (needed by @nx/dotnet plugin)
+                dotnet --version
+
+                # Node.js musl build from unofficial-builds.nodejs.org
+                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v\${NODE_VERSION}/node-v\${NODE_VERSION}-linux-x64-musl.tar.xz -o node.tar.xz
                 tar -xJf node.tar.xz
-                mv node-v22.16.0-linux-x64-musl /usr/local/node
-
+                mv node-v\${NODE_VERSION}-linux-x64-musl /usr/local/node
                 export PATH=\"/usr/local/node/bin:\$PATH\"
+                node --version
 
-                echo Node: \$(node -v)
-                echo NPM: \$(npm -v)
+                npm i -g pnpm@\${PNPM_VERSION} --force
 
-                # Install PNPM
-                npm i -g pnpm@${PNPM_VERSION} --force
-                pnpm --version
+                # Help clang find GCC runtime (crtbeginS.o, libgcc) and use lld for jemalloc build
+                GCC_DIR=\$(dirname \$(find /usr/lib/gcc -name crtbeginS.o | head -1))
+                export CFLAGS=\"\${CFLAGS} -fuse-ld=lld --gcc-install-dir=\${GCC_DIR}\"
 
-                # Install deps and run native build
                 pnpm install --frozen-lockfile
                 rustup target add x86_64-unknown-linux-musl
                 pnpm nx run-many --verbose --target=build-native -- --target=x86_64-unknown-linux-musl
@@ -216,22 +223,30 @@ jobs:
             build: |
               set -e
               apt-get update
+              apt-get install -y curl ca-certificates git xz-utils gpg
 
-              # Install Java 21
-              apt-get install -y openjdk-21-jdk
-              export JAVA_HOME=/usr/lib/jvm/java-21-openjdk-amd64
-              export PATH="$JAVA_HOME/bin:$PATH"
-              java --version
+              # Install mise from the signed apt repo
+              install -dm 755 /etc/apt/keyrings
+              curl -fsSL https://mise.jdx.dev/gpg-key.pub | gpg --dearmor -o /etc/apt/keyrings/mise-archive-keyring.gpg
+              echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=$(dpkg --print-architecture)] https://mise.jdx.dev/deb stable main" > /etc/apt/sources.list.d/mise.list
+              apt-get update
+              apt-get install -y mise
 
-              curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
-              apt-get install -y nodejs=22.16.0-1nodesource1
+              # Provision Node, Java, .NET, Maven, corepack from mise.toml
+              cd /build
+              mise trust mise.toml
+              mise install
+              eval "$(mise env -s bash)"
 
-              export PATH="/usr/local/bin:$PATH"
-              node --version
-              npm --version
+              # Help clang find GCC runtime (crtbeginS.o, libgcc) and use lld for jemalloc build
+              export CFLAGS="${CFLAGS} -fuse-ld=lld --gcc-toolchain=/usr/aarch64-unknown-linux-gnu"
 
-              npm i -g pnpm@${PNPM_VERSION} --force
-              pnpm --version
+              # Build jemalloc with 64 KiB allocator page so the binary works on aarch64
+              # Linux kernels with 4K/16K/64K pages (Asahi, Ampere, Graviton, etc.).
+              export JEMALLOC_SYS_WITH_LG_PAGE=16
+
+              corepack enable
+              corepack prepare --activate
 
               pnpm install --frozen-lockfile
               rustup target add aarch64-unknown-linux-gnu
@@ -259,28 +274,38 @@ jobs:
             build: |
               bash -c "
                 set -e
+                # mise's core node/java backends don't ship musl binaries and fall back to
+                # compile-from-source on Alpine, which fails. Install via apk + tarball instead.
                 echo 'https://dl-cdn.alpinelinux.org/alpine/edge/community' >> /etc/apk/repositories
-                apk add --no-cache curl xz openjdk21
+                apk add --no-cache curl xz openjdk21 build-base lld dotnet9-sdk
 
-                # Set up Java 21
+                # Java 21
                 export JAVA_HOME=/usr/lib/jvm/java-21-openjdk
                 export PATH=\"\$JAVA_HOME/bin:\$PATH\"
                 java --version
 
-                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v22.16.0/node-v22.16.0-linux-x64-musl.tar.xz -o node.tar.xz
+                # .NET 9 SDK (needed by @nx/dotnet plugin)
+                dotnet --version
+
+                # Node.js musl build from unofficial-builds.nodejs.org. Container is x64;
+                # rust cross-compiles to aarch64-unknown-linux-musl, so the host node binary
+                # is x64-musl regardless of the build target.
+                curl -fsSL https://unofficial-builds.nodejs.org/download/release/v\${NODE_VERSION}/node-v\${NODE_VERSION}-linux-x64-musl.tar.xz -o node.tar.xz
                 tar -xJf node.tar.xz
-                mv node-v22.16.0-linux-x64-musl /usr/local/node
-
+                mv node-v\${NODE_VERSION}-linux-x64-musl /usr/local/node
                 export PATH=\"/usr/local/node/bin:\$PATH\"
+                node --version
 
-                echo Node: \$(node -v)
-                echo NPM: \$(npm -v)
+                npm i -g pnpm@\${PNPM_VERSION} --force
 
-                # Install PNPM
-                npm i -g pnpm@${PNPM_VERSION} --force
-                pnpm --version
+                # Help clang find GCC runtime (crtbeginS.o, libgcc) and use lld for jemalloc build
+                GCC_DIR=\$(dirname \$(find /aarch64-linux-musl-cross/lib/gcc -name crtbeginS.o | head -1))
+                export CFLAGS=\"\${CFLAGS} -fuse-ld=lld --gcc-install-dir=\${GCC_DIR}\"
+
+                # Build jemalloc with 64 KiB allocator page so the binary works on aarch64
+                # Linux kernels with 4K/16K/64K pages (Asahi, Ampere, Graviton, etc.).
+                export JEMALLOC_SYS_WITH_LG_PAGE=16
 
-                # Install deps and run native build
                 pnpm install --frozen-lockfile
                 rustup target add aarch64-unknown-linux-musl
                 pnpm nx run-many --verbose --target=build-native -- --target=aarch64-unknown-linux-musl
@@ -289,13 +314,14 @@ jobs:
             target: aarch64-pc-windows-msvc
             setup: |-
               choco install openjdk --version=21.0.0 -y
+              choco install dotnet-9.0-sdk -y
               rustup target add aarch64-pc-windows-msvc
             build: |
               export JAVA_HOME="C:\Program Files\OpenJDK\jdk-21"
               export PATH="$JAVA_HOME\bin:$PATH"
               java -version
               pnpm nx run-many --target=build-native -- --target=aarch64-pc-windows-msvc
-    name: stable - ${{ matrix.settings.target }} - node@22.16.0
+    name: stable - ${{ matrix.settings.target }} - node@26.3.0
     runs-on: ${{ matrix.settings.host }}
     steps:
       - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
@@ -303,6 +329,10 @@ jobs:
           repository: ${{ needs.resolve-required-data.outputs.repo || github.repository }}
           ref: ${{ needs.resolve-required-data.outputs.ref || github.ref }}
 
+      - name: Set verbose logging from debug mode
+        if: runner.debug == '1'
+        run: echo "NX_VERBOSE_LOGGING=true" >> "$GITHUB_ENV"
+
       - name: Setup dev tools with mise
         uses: jdx/mise-action@146a28175021df8ca24f8ee1828cc2a60f980bd5 # v3
         if: ${{ !matrix.settings.docker }}
@@ -324,11 +354,6 @@ jobs:
             target/
           key: ${{ matrix.settings.target }}-cargo-registry
 
-      - uses: goto-bus-stop/setup-zig@abea47f85e598557f500fa1fd2ab7464fcb39406 # v2.2.1
-        if: ${{ matrix.settings.target == 'armv7-unknown-linux-gnueabihf' }}
-        with:
-          version: 0.10.0
-
       - name: Setup toolchain
         run: ${{ matrix.settings.setup }}
         if: ${{ matrix.settings.setup }}
@@ -354,12 +379,27 @@ jobs:
           architecture: x86
 
       - name: Build in docker
-        uses: addnab/docker-run-action@4f65fabd2431ebc8d299f8e5a018d79a769ae185 # v3
         if: ${{ matrix.settings.docker }}
-        with:
-          image: ${{ matrix.settings.docker }}
-          options: --user 0:0 -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index -v ${{ github.workspace }}:/build -w /build
-          run: ${{ matrix.settings.build }}
+        shell: bash
+        env:
+          BUILD_SCRIPT: ${{ matrix.settings.build }}
+        run: |
+          SCRIPT_FILE=$(mktemp)
+          echo "$BUILD_SCRIPT" > "$SCRIPT_FILE"
+          docker run --rm \
+            --user 0:0 \
+            -e NODE_VERSION \
+            -e PNPM_VERSION \
+            -e NX_GRADLE_PROJECT_GRAPH_TIMEOUT \
+            -e NX_VERBOSE_LOGGING \
+            -v ${{ github.workspace }}/.cargo-cache/git/db:/usr/local/cargo/git/db \
+            -v ${{ github.workspace }}/.cargo/registry/cache:/usr/local/cargo/registry/cache \
+            -v ${{ github.workspace }}/.cargo/registry/index:/usr/local/cargo/registry/index \
+            -v ${{ github.workspace }}:/build \
+            -v "$SCRIPT_FILE:/build-script.sh" \
+            -w /build \
+            ${{ matrix.settings.docker }} \
+            bash /build-script.sh
 
       - name: Build
         run: ${{ matrix.settings.build }}
@@ -393,24 +433,22 @@ jobs:
         env:
           DEBUG: napi:*
           RUSTUP_IO_THREADS: 1
-          NX_PREFER_TS_NODE: true
           PLAYWRIGHT_BROWSERS_PATH: 0
-          NODE_VERSION: 22.16.0
+          NODE_VERSION: 26.3.0
+          NX_GRADLE_DISABLE: 'true'
+          NX_DOTNET_DISABLE: 'true'
+          NODE_OPTIONS: '--max-old-space-size=4096'
         with:
           operating_system: freebsd
           version: '14.0'
           architecture: x86-64
-          environment_variables: DEBUG RUSTUP_IO_THREADS CI NX_PREFER_TS_NODE PLAYWRIGHT_BROWSERS_PATH NODE_VERSION
+          environment_variables: DEBUG RUSTUP_IO_THREADS CI PLAYWRIGHT_BROWSERS_PATH NODE_VERSION NX_GRADLE_DISABLE NX_DOTNET_DISABLE NODE_OPTIONS
           shell: bash
           run: |
             env
             whoami
-            sudo pkg install -y -f node libnghttp2 www/npm git openjdk17
-            sudo npm install --location=global --ignore-scripts pnpm@10.11.1
-            # Set up Java 17
-            export JAVA_HOME=/usr/local/openjdk17
-            export PATH="$JAVA_HOME/bin:$PATH"
-            java --version
+            sudo pkg install -y -f node libnghttp2 www/npm git ca_root_nss
+            sudo npm install --location=global --ignore-scripts pnpm@11.2.2
             curl https://sh.rustup.rs -sSf --output rustup.sh
             sh rustup.sh -y --profile minimal --default-toolchain stable
             source "$HOME/.cargo/env"
@@ -466,17 +504,46 @@ jobs:
             pnpm store prune || true
             rm -rf ~/.npm || true
             rm -rf ~/.pnpm-store || true
-            # Remove Rust build artifacts if any
-            rm -rf ~/.cargo/registry || true
-            rm -rf ~/.cargo/git || true
+            # Clean Rust extras but keep registry/git (needed for cargo to resolve deps)
             rm -rf ~/.rustup/toolchains/*/share || true
             # Remove other development tool caches
             rm -rf ~/.cache/* || true
+
+            # Remove unnecessary workspace directories
+            rm -rf docs astro-docs nx-dev || true
+
             echo "Checking disk space after cleanup"
             df -h
             
+            # Disable core dumps - OOM'd Node processes write multi-GB core files that fill the disk
+            ulimit -c 0
+
             echo "Building FreeBSD bindings"
-            pnpm nx run-many --verbose --outputStyle stream --target=build-native -- --target=x86_64-unknown-freebsd
+            BUILD_EXIT=0
+            pnpm nx run-many --verbose --outputStyle stream --target=build-native -- --target=x86_64-unknown-freebsd || BUILD_EXIT=$?
+
+            echo "=== Disk usage after build ==="
+            df -h
+
+            if [ "$BUILD_EXIT" -ne 0 ]; then
+              echo "Build failed with exit code $BUILD_EXIT"
+              echo "=== Disk usage by top-level directories ==="
+              du -sh /* 2>/dev/null | sort -rh | head -20
+              echo "=== Disk usage in home directory ==="
+              du -sh ~/* 2>/dev/null | sort -rh | head -20
+              echo "=== Disk usage in workspace ==="
+              du -sh /home/runner/work/nx/nx/* 2>/dev/null | sort -rh | head -20
+              echo "=== Disk usage in .nx ==="
+              du -sh /home/runner/work/nx/nx/.nx/* 2>/dev/null | sort -rh | head -20
+              echo "=== Disk usage in cargo/rustup ==="
+              du -sh ~/.cargo/* ~/.rustup/* 2>/dev/null | sort -rh | head -20
+              echo "=== Core dumps ==="
+              find / -name "*.core" -o -name "core.*" -o -name "core" 2>/dev/null | head -10
+              exit $BUILD_EXIT
+            fi
+
+            echo "Build succeeded"
+            
             echo "Cleaning up"
             pnpm nx reset
             rm -rf node_modules
@@ -514,6 +581,10 @@ jobs:
           repository: ${{ needs.resolve-required-data.outputs.repo || github.repository }}
           ref: ${{ needs.resolve-required-data.outputs.ref || github.ref }}
 
+      - name: Set verbose logging from debug mode
+        if: runner.debug == '1'
+        run: echo "NX_VERBOSE_LOGGING=true" >> "$GITHUB_ENV"
+
       - name: Setup dev tools with mise
         uses: jdx/mise-action@146a28175021df8ca24f8ee1828cc2a60f980bd5 # v3
 
@@ -528,6 +599,9 @@ jobs:
       - name: Install dependencies
         run: pnpm install --frozen-lockfile
 
+      - name: Restore .NET packages
+        run: dotnet restore nx.sln
+
       - name: Download all artifacts
         uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
         with:
@@ -545,19 +619,19 @@ jobs:
           pnpm build:wasm
       - name: Publish
         env:
-          VERSION: ${{ needs.resolve-required-data.outputs.version }}
+          # Not named `VERSION` to avoid MSBuild adopting it as $(Version).
+          NX_PUBLISH_VERSION: ${{ needs.resolve-required-data.outputs.version }}
           DRY_RUN: ${{ needs.resolve-required-data.outputs.dry_run_flag }}
           PUBLISH_BRANCH: ${{ needs.resolve-required-data.outputs.publish_branch }}
-          NX_VERBOSE_LOGGING: true
         run: |
           echo ""
           # Create and check out the publish branch
           git checkout -b $PUBLISH_BRANCH
           echo ""
-          echo "Version set to: $VERSION"
+          echo "Version set to: $NX_PUBLISH_VERSION"
           echo "DRY_RUN set to: $DRY_RUN"
           echo ""
-          pnpm nx-release --local=false $VERSION $DRY_RUN
+          pnpm nx-release --local=false $NX_PUBLISH_VERSION $DRY_RUN
 
       - name: (Stable Release Only) Trigger Docs Release
         # Publish docs only on a full release

.gitignore

@@ -25,7 +25,14 @@ jest.debug.config.js
 /nx-dev/nx-dev/public/documentation
 /nx-dev/nx-dev/public/tutorials
 /nx-dev/nx-dev/public/images/open-graph
-**/tests/temp-db
+/nx-dev/nx-dev/public/robots.txt
+/nx-dev/nx-dev/public/sitemap-0.xml
+/nx-dev/nx-dev/public/sitemap.xml
+
+# Banner JSON files are generated during static builds
+/nx-dev/nx-dev/lib/banner.json
+/astro-docs/src/content/banner.json
+**/tests/temp-db*
 
 # Issues scraper creates these files, stored by github's cache
 /scripts/issues-scraper/cached
@@ -67,7 +74,7 @@ dependency-reduced-pom.xml
 *.wasm
 /wasi-sdk*
 
-vite.config.*.timestamp*
+*.config.timestamp*
 
 storybook-static
 
@@ -76,6 +83,7 @@ storybook-static
 .kotlin
 
 .claude/settings.local.json
+.claude/scheduled_tasks.lock
 CLAUDE.local.md
 
 .cursor/mcp.json
@@ -99,6 +107,7 @@ node_modules/
 *.ntvs*
 *.njsproj
 *.sln
+!/nx.sln
 *.sw?
 .specstory/**
 .cursorindexingignore
@@ -110,7 +119,8 @@ node_modules/
 # Upstream docs local configuration (machine-specific)
 .upstreamdocs.local.json
 
-astro-docs/.netlify
+# Netlify build artifacts
+.netlify
 
 coverage
 
@@ -123,6 +133,42 @@ packages/angular-rspack/README.md
 packages/angular-rspack-compiler/README.md
 packages/dotnet/README.md
 packages/maven/README.md
+packages/nx/README.md
+packages/devkit/README.md
+packages/workspace/README.md
+packages/js/README.md
+packages/jest/README.md
+packages/eslint/README.md
+packages/eslint-plugin/README.md
+packages/vitest/README.md
+packages/cypress/README.md
+packages/playwright/README.md
+packages/vite/README.md
+packages/webpack/README.md
+packages/rollup/README.md
+packages/docker/README.md
+packages/gradle/README.md
+packages/rsbuild/README.md
+packages/web/README.md
+packages/node/README.md
+packages/module-federation/README.md
+packages/nest/README.md
+packages/rspack/README.md
+packages/storybook/README.md
+packages/react/README.md
+packages/vue/README.md
+packages/esbuild/README.md
+packages/angular/README.md
+packages/express/README.md
+packages/plugin/README.md
+packages/react-native/README.md
+packages/next/README.md
+packages/remix/README.md
+packages/detox/README.md
+packages/expo/README.md
+packages/nuxt/README.md
+packages/create-nx-workspace/README.md
+packages/create-nx-plugin/README.md
 
 test-output
 test-results
@@ -133,3 +179,14 @@ test-results
 # .NET build output
 /packages/dotnet/analyzer/bin
 /packages/dotnet/analyzer/obj
+/packages/dotnet/analyzer.Tests/bin
+/packages/dotnet/analyzer.Tests/obj
+/*.deb
+.nx/polygraph
+.claude/worktrees
+
+.nx/self-healing
+e2e/**/*.d.ts
+e2e/**/*.d.ts.map
+
+.nx/migrate-runs

.mcp.json

@@ -1,9 +0,0 @@
-{
-  "mcpServers": {
-    "nx-mcp": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["nx", "mcp"]
-    }
-  }
-}

.nx/nx-mcp-config.json

@@ -0,0 +1,3 @@
+{
+  "experimentalPolygraph": true
+}

.nx/workflows/agents.yaml

@@ -5,16 +5,21 @@ common-env-vars: &common-env-vars
   GIT_COMMITTER_NAME: Test
   SELECTED_PM: 'pnpm'
   NX_NATIVE_LOGGING: 'nx::native::db'
+  # Pin corepack to the pnpm version from packageManager. Without this, corepack
+  # falls back to "latest" in directories that have no packageManager field
+  # (e.g. e2e temp dirs created by create-nx-workspace), pulling pnpm 11 and
+  # breaking install. Same treatment as .github/workflows/{ci,e2e-matrix}.yml.
+  COREPACK_DEFAULT_TO_LATEST: '0'
   # These are need for build and link validation for next.js and astro apps
   NEXT_PUBLIC_ASTRO_URL: 'https://master--nx-docs.netlify.app'
   NX_DEV_URL: 'https://canary.nx.dev'
 
 common-init-steps: &common-init-steps
   - name: Checkout
-    uses: 'nrwl/nx-cloud-workflows/v5/workflow-steps/checkout/main.yaml'
+    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/checkout/main.yaml'
 
   - name: Cache restore
-    uses: 'nrwl/nx-cloud-workflows/v5/workflow-steps/cache/main.yaml'
+    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/cache/main.yaml'
     inputs:
       key: 'pnpm-lock.yaml'
       paths: ~/.local/share/pnpm/store
@@ -22,7 +27,7 @@ common-init-steps: &common-init-steps
 
   # reads mise.toml and installs toolchains needed for repo
   - name: Setup toolchains
-    uses: 'nrwl/nx-cloud-workflows/v5/workflow-steps/install-mise/main.yaml'
+    uses: 'nrwl/nx-cloud-workflows/v6/workflow-steps/install-mise/main.yaml'
 
   - name: Verify toolchain versions
     script: |
@@ -36,6 +41,17 @@ common-init-steps: &common-init-steps
 
   - name: Install system deps
     script: |
+      # apt mirror+file failover: tab-separated; printf preserves \t (YAML heredocs don't).
+      printf 'https://archive.ubuntu.com/ubuntu/\tpriority:1\n'       | sudo tee /etc/apt/apt-mirrors.txt > /dev/null
+      printf 'https://security.ubuntu.com/ubuntu/\tpriority:2\n'      | sudo tee -a /etc/apt/apt-mirrors.txt > /dev/null
+      printf 'http://azure.archive.ubuntu.com/ubuntu/\tpriority:3\n'  | sudo tee -a /etc/apt/apt-mirrors.txt > /dev/null
+      # Retries=0: mirror+file already retries via failover; apt-level retries multiply stall on a dead mirror.
+      sudo tee /etc/apt/apt.conf.d/80-nx-mirror-failover > /dev/null <<'EOF'
+      Acquire::http::Timeout "5";
+      Acquire::https::Timeout "5";
+      Acquire::Retries "0";
+      EOF
+      sudo sed -i 's|http://archive.ubuntu.com/ubuntu|mirror+file:/etc/apt/apt-mirrors.txt|g; s|http://security.ubuntu.com/ubuntu|mirror+file:/etc/apt/apt-mirrors.txt|g' /etc/apt/sources.list
       sudo apt-get update
       sudo apt-get install -y ca-certificates lsof libvips-dev libglib2.0-dev libgirepository1.0-dev zip unzip
 
@@ -52,11 +68,19 @@ common-init-steps: &common-init-steps
     script: |
       cargo fetch
 
+  - name: Install hyperfine
+    script: |
+      cargo install hyperfine
+
   - name: Setup gradle
     script: |
       ./gradlew wrapper
       ./gradlew --version
 
+  - name: Restore .NET analyzer projects
+    script: |
+      dotnet restore nx.sln
+
   - name: Configure git metadata (needed for lerna smoke tests)
     script: |
       git config --global user.email test@test.com

.nx/workflows/dynamic-changesets.yaml

@@ -1,14 +1,10 @@
 distribute-on:
-  default: auto linux-large, 3 linux-extra-large
+  extra-small-changeset: 6 linux-large, 3 linux-extra-large
+  small-changeset: 6 linux-large, 4 linux-extra-large
+  medium-changeset: 6 linux-large, 5 linux-extra-large
+  large-changeset: 6 linux-large, 6 linux-extra-large
+  extra-large-changeset: 8 linux-large, 8 linux-extra-large
 assignment-rules:
-  - projects:
-      - e2e-gradle
-    targets:
-      - e2e-ci**
-    run-on:
-      - agent: linux-extra-large
-        parallelism: 1
-
   - projects:
       - nx
       - workspace
@@ -23,41 +19,33 @@ assignment-rules:
       - agent: linux-extra-large
         parallelism: 1
 
-  - projects:
-      - e2e-release
-      - e2e-angular
-      - e2e-react
-      - e2e-next
-      - e2e-web
-      - e2e-eslint
-      - e2e-remix
-      - e2e-cypress
-      - e2e-docker
-      - e2e-js
-      - e2e-nx-init
-      - e2e-dotnet
-      - e2e-workspace-create
-      - e2e-rollup
-    targets:
-      - e2e-ci**
+  # Module federation e2e tests build + serve a host and its remotes (several
+  # webpack/rspack builds at once) — each one saturates ~7 cores. Pin them to
+  # the larger extra-large agents, one per machine. Must precede e2e-ci**.
+  - targets:
+      - e2e-ci--src/module-federation**
     run-on:
-      - agent: linux-large
-        parallelism: 1
       - agent: linux-extra-large
         parallelism: 1
 
-  # All other e2e tests can run in parallel
   - targets:
       - e2e-ci**
     run-on:
       - agent: linux-large
-        parallelism: 2
-      - agent: linux-extra-large
         parallelism: 3
+      - agent: linux-extra-large
+        parallelism: 6
+
+  - targets:
+      - bench:*
+    run-on:
+      - agent: linux-large
+        parallelism: 1
 
   # These projects should not need to be isolated.
   - projects:
       - nx-dev
+      - astro-docs
     targets:
       - build*
     run-on:

.nx/workflows/sandboxing-config.yaml

@@ -0,0 +1,28 @@
+exclude-reads:
+  - packages/nx/src/native/*.node
+  - packages/nx/dist/src/native/*.node
+  - 'dist/target/**'
+exclude-writes:
+  - '**/.swc/**'
+  - 'dist/target/**'
+
+task-exclusions:
+  - target: lint
+    exclude-reads:
+      - '**/dist/**/*.json'
+  # TODO: populate-local-registry-storage is doing too much — it reads all build
+  # outputs and writes version-bumped packages across the entire workspace during
+  # nx-release. We're reworking this task to have more focused I/O and will fix
+  # the inputs/outputs properly after that.
+  - project: '@nx/nx-source'
+    target: populate-local-registry-storage
+    exclude-reads:
+      - '**'
+    exclude-writes:
+      - '**'
+
+  - project: graph-client
+    target: build-client
+    exclude-reads:
+      - '**/*.stories.{js,jsx,ts,tsx,mdx}'
+      - '**/*.{spec,test}.{js,jsx,ts,tsx}'

.nxignore

@@ -1,3 +1,4 @@
+benchmarks/packages
 nx-dev/**/jest.config.js
 .next
 _files

.opencode/agents/ci-watcher.md

@@ -0,0 +1,479 @@
+---
+description: Polls Nx Cloud CI pipeline and self-healing status. Returns structured state when actionable. Spawned by /nx-cloud-ci-monitor command to monitor CI Attempt status.
+mode: subagent
+---
+
+# CI Watcher Subagent
+
+You are a CI monitoring subagent responsible for polling Nx Cloud CI Attempt status and self-healing state. You report status back to the main agent - you do NOT make apply/reject decisions.
+
+## Your Responsibilities
+
+1. Poll CI status using the `ci_information` MCP tool
+2. Implement exponential backoff between polls
+3. Return structured state when an actionable condition is reached
+4. Track iteration count and elapsed time
+5. Output status updates based on verbosity level
+
+## Input Parameters (from Main Agent)
+
+The main agent may provide these optional parameters in the prompt:
+
+| Parameter           | Description                                              |
+| ------------------- | -------------------------------------------------------- |
+| `branch`            | Branch to monitor (auto-detected if not provided)        |
+| `expectedCommitSha` | Commit SHA that should trigger a new CI Attempt          |
+| `previousCipeUrl`   | CI Attempt URL before the action (to detect change)      |
+| `subagentTimeout`   | Polling timeout in minutes (default: 60)                 |
+| `verbosity`         | Output level: minimal, medium, verbose (default: medium) |
+
+When `expectedCommitSha` or `previousCipeUrl` is provided, you must detect whether a new CI Attempt has spawned.
+
+## MCP Tool Reference
+
+### `ci_information`
+
+**Input:**
+
+```json
+{
+  "branch": "string (optional, defaults to current git branch)",
+  "select": "string (optional, comma-separated field names)",
+  "pageToken": "number (optional, 0-based pagination for long strings)"
+}
+```
+
+**Output:**
+
+```json
+{
+  "cipeStatus": "NOT_STARTED | IN_PROGRESS | SUCCEEDED | FAILED | CANCELED | TIMED_OUT",
+  "cipeUrl": "string",
+  "branch": "string",
+  "commitSha": "string | null",
+  "failedTaskIds": "string[]",
+  "verifiedTaskIds": "string[]",
+  "selfHealingEnabled": "boolean",
+  "selfHealingStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "verificationStatus": "NOT_STARTED | IN_PROGRESS | COMPLETED | FAILED | NOT_EXECUTABLE | null",
+  "userAction": "NONE | APPLIED | REJECTED | APPLIED_LOCALLY | APPLIED_AUTOMATICALLY | null",
+  "failureClassification": "string | null",
+  "taskOutputSummary": "string | null",
+  "suggestedFixReasoning": "string | null",
+  "suggestedFixDescription": "string | null",
+  "suggestedFix": "string | null",
+  "shortLink": "string | null",
+  "couldAutoApplyTasks": "boolean | null",
+  "confidence": "number | null",
+  "confidenceReasoning": "string | null"
+}
+```
+
+**Select Parameter:**
+
+| Usage           | Returns                                                     |
+| --------------- | ----------------------------------------------------------- |
+| No `select`     | Formatted overview (truncated, not recommended for polling) |
+| Single field    | Raw value with pagination for long strings                  |
+| Multiple fields | Object with requested field values                          |
+
+**Field Sets for Efficient Polling:**
+
+```yaml
+WAIT_FIELDS:
+  'cipeUrl,commitSha,cipeStatus'
+  # Minimal fields for detecting new CI Attempt
+
+LIGHT_FIELDS:
+  'cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning'
+  # Status fields for determining actionable state
+
+HEAVY_FIELDS:
+  'taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription'
+  # Large content fields - fetch only when returning to main agent
+```
+
+## Initial Wait
+
+Before first poll, wait based on context:
+
+- **Fresh start (no expected CIPE):** Wait 60 seconds to allow CI to start
+- **Expecting new CIPE:** Wait 30 seconds (action already triggered)
+
+**IMPORTANT:** Always run sleep in foreground, NOT as background command.
+
+```bash
+sleep 60  # or 30 if expecting new CIPE (FOREGROUND, not background)
+```
+
+## Two-Phase Operation
+
+The subagent operates in one of two modes depending on input:
+
+### Mode 1: Fresh Start (no `expectedCommitSha` or `previousCipeUrl`)
+
+Normal polling - process whatever CIPE is returned by `ci_information`.
+
+### Mode 2: Wait-for-New-CIPE (when `expectedCommitSha` or `previousCipeUrl` provided)
+
+**CRITICAL**: When expecting a new CIPE, the subagent must **completely ignore** the old/stale CIPE. Do NOT process its status, do NOT return actionable states based on it.
+
+#### Phase A: Wait Mode
+
+1. Start a **new-CIPE timeout** timer (default: 30 minutes)
+2. On each poll of `ci_information`:
+   - Check if CIPE is NEW:
+     - `cipeUrl` differs from `previousCipeUrl` → **new CIPE detected**
+     - `commitSha` matches `expectedCommitSha` → **correct CIPE detected**
+   - If still OLD CIPE: **ignore all status fields**, just wait and poll again
+   - Do NOT return `fix_available`, `ci_success`, etc. based on old CIPE!
+3. Output wait status (see below)
+4. If timeout (30 min) reached → return `no_new_cipe`
+
+#### Phase B: Normal Polling (after new CIPE detected)
+
+Once new CIPE is detected:
+
+1. Clear the new-CIPE timeout
+2. Switch to normal polling mode
+3. Process the NEW CIPE's status normally
+4. Return when actionable state reached
+
+### Wait Mode Output
+
+While in wait mode, output clearly that you're waiting (not processing):
+
+```
+[CI Monitor] ═══════════════════════════════════════════════════════
+[CI Monitor] WAIT MODE - Expecting new CI Attempt
+[CI Monitor] Expected SHA: <expectedCommitSha>
+[CI Monitor] Previous CI Attempt: <previousCipeUrl>
+[CI Monitor] ═══════════════════════════════════════════════════════
+
+[CI Monitor] Polling... (elapsed: 0m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 1m 30s)
+[CI Monitor] Still seeing previous CI Attempt (ignoring): <oldCipeUrl>
+
+[CI Monitor] Polling... (elapsed: 2m 30s)
+[CI Monitor] ✓ New CI Attempt detected! URL: <newCipeUrl>, SHA: <newCommitSha>
+[CI Monitor] Switching to normal polling mode...
+```
+
+### Why This Matters (Context Preservation)
+
+**The problem**: Stale CIPE data can be very large:
+
+- `taskOutputSummary`: potentially thousands of characters of build/test output
+- `suggestedFix`: entire patch files
+- `suggestedFixReasoning`: detailed explanation
+
+If subagent returns stale CIPE data to main agent, it **pollutes main agent's context** with useless information (we already processed that CIPE). This wastes valuable context window.
+
+**Without wait mode:**
+
+1. Poll `ci_information` → get old CIPE with huge data
+2. Return to main agent with all that stale data
+3. Main agent's context gets polluted with useless info
+4. Main agent has to process/ignore it anyway
+
+**With wait mode:**
+
+1. Poll `ci_information` → get old CIPE → **ignore it, don't return**
+2. Keep waiting internally (stale data stays in subagent)
+3. New CIPE appears → switch to normal mode
+4. Return to main agent with only the NEW, relevant CIPE data
+
+## Polling Loop
+
+### Subagent State Management
+
+Maintain internal accumulated state across polls:
+
+```
+accumulated_state = {}
+```
+
+### Call `ci_information` MCP Tool
+
+**Wait Mode (expecting new CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeUrl,commitSha,cipeStatus"
+})
+```
+
+Only fetch minimal fields needed to detect CI Attempt change. Do NOT fetch heavy fields - stale data wastes context.
+
+**Normal Mode (processing CI Attempt):**
+
+```
+ci_information({
+  branch: "<branch_name>",
+  select: "cipeStatus,cipeUrl,branch,commitSha,selfHealingStatus,verificationStatus,userAction,failedTaskIds,verifiedTaskIds,selfHealingEnabled,failureClassification,couldAutoApplyTasks,shortLink,confidence,confidenceReasoning"
+})
+```
+
+Merge response into `accumulated_state` after each poll.
+
+### Analyze Response
+
+**If in Wait Mode** (expecting new CIPE):
+
+1. Check if CIPE is new (see Two-Phase Operation above)
+2. If old CIPE → **ignore status**, output wait message, poll again
+3. If new CIPE → switch to normal mode, continue below
+
+**If in Normal Mode**:
+Based on the response, decide whether to **keep polling** or **return to main agent**.
+
+### Keep Polling When
+
+Continue polling (with backoff) if ANY of these conditions are true:
+
+| Condition                               | Reason                                   |
+| --------------------------------------- | ---------------------------------------- |
+| `cipeStatus == 'IN_PROGRESS'`           | CI still running                         |
+| `cipeStatus == 'NOT_STARTED'`           | CI hasn't started yet                    |
+| `selfHealingStatus == 'IN_PROGRESS'`    | Self-healing agent working               |
+| `selfHealingStatus == 'NOT_STARTED'`    | Self-healing not started yet             |
+| `failureClassification == 'FLAKY_TASK'` | Auto-rerun in progress                   |
+| `userAction == 'APPLIED_AUTOMATICALLY'` | New CI Attempt spawning after auto-apply |
+
+When `couldAutoApplyTasks == true`:
+
+- `verificationStatus` = `NOT_STARTED`, `IN_PROGRESS` → keep polling (verification still in progress)
+- `verificationStatus` = `COMPLETED` → return `fix_auto_applying` (auto-apply will happen, main agent spawns wait mode subagent)
+- `verificationStatus` = `FAILED`, `NOT_EXECUTABLE` → return `fix_available` (auto-apply won't happen, needs manual action)
+
+### Exponential Backoff
+
+Between polls, wait with exponential backoff:
+
+| Poll Attempt | Wait Time         |
+| ------------ | ----------------- |
+| 1st          | 60 seconds        |
+| 2nd          | 90 seconds        |
+| 3rd+         | 120 seconds (cap) |
+
+Reset to 60 seconds when state changes significantly.
+
+**IMPORTANT:** Run sleep in foreground (NOT as background command). Background sleep causes "What should Claude do?" prompts when completed.
+
+```bash
+# Example backoff - run in FOREGROUND
+sleep 60   # First wait
+sleep 90   # Second wait
+sleep 120  # Third and subsequent waits (capped)
+```
+
+### Fetch Heavy Fields on Actionable State
+
+Before returning to main agent, fetch heavy fields if the status requires them:
+
+| Status              | Heavy Fields Needed                                                            |
+| ------------------- | ------------------------------------------------------------------------------ |
+| `ci_success`        | None                                                                           |
+| `fix_auto_applying` | None                                                                           |
+| `fix_available`     | `taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription` |
+| `fix_failed`        | `taskOutputSummary`                                                            |
+| `no_fix`            | `taskOutputSummary`                                                            |
+| `environment_issue` | None                                                                           |
+| `no_new_cipe`       | None                                                                           |
+| `polling_timeout`   | None                                                                           |
+| `cipe_canceled`     | None                                                                           |
+| `cipe_timed_out`    | None                                                                           |
+
+```
+# Example: fetching heavy fields for fix_available
+ci_information({
+  branch: "<branch_name>",
+  select: "taskOutputSummary,suggestedFix,suggestedFixReasoning,suggestedFixDescription"
+})
+```
+
+Merge response into `accumulated_state`, then return merged state to main agent.
+
+**Pagination:** Heavy string fields return first page only. If `hasMore` indicated, include in return format so main agent knows more content available.
+
+### Return to Main Agent When
+
+Return immediately with structured state if ANY of these conditions are true:
+
+| Status              | Condition                                                                                                                                                 |
+| ------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | `cipeStatus == 'SUCCEEDED'`                                                                                                                               |
+| `fix_auto_applying` | `selfHealingStatus == 'COMPLETED'` AND `couldAutoApplyTasks == true` AND `verificationStatus == 'COMPLETED'`                                              |
+| `fix_available`     | `selfHealingStatus == 'COMPLETED'` AND `suggestedFix != null` AND (`couldAutoApplyTasks != true` OR `verificationStatus` in (`FAILED`, `NOT_EXECUTABLE`)) |
+| `fix_failed`        | `selfHealingStatus == 'FAILED'`                                                                                                                           |
+| `environment_issue` | `failureClassification == 'ENVIRONMENT_STATE'`                                                                                                            |
+| `no_fix`            | `cipeStatus == 'FAILED'` AND (`selfHealingEnabled == false` OR `selfHealingStatus == 'NOT_EXECUTABLE'`)                                                   |
+| `no_new_cipe`       | `expectedCommitSha` or `previousCipeUrl` provided, but no new CI Attempt detected after 30 min                                                            |
+| `polling_timeout`   | Subagent has been polling for > configured timeout (default 60 min)                                                                                       |
+| `cipe_canceled`     | `cipeStatus == 'CANCELED'`                                                                                                                                |
+| `cipe_timed_out`    | `cipeStatus == 'TIMED_OUT'`                                                                                                                               |
+
+## Subagent Timeout
+
+Track elapsed time. If you have been polling for more than **60 minutes** (configurable via main agent), return with `status: polling_timeout`.
+
+## Return Format
+
+When returning to the main agent, provide a structured response with accumulated state:
+
+```
+## CI Monitor Result
+
+**Status:** <status>
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### CI Attempt Details
+- **Status:** <cipeStatus>
+- **URL:** <cipeUrl>
+- **Branch:** <branch>
+- **Commit:** <commitSha>
+- **Failed Tasks:** <failedTaskIds>
+- **Verified Tasks:** <verifiedTaskIds>
+
+### Self-Healing Details
+- **Enabled:** <selfHealingEnabled>
+- **Status:** <selfHealingStatus>
+- **Verification:** <verificationStatus>
+- **User Action:** <userAction>
+- **Classification:** <failureClassification>
+- **Confidence:** <confidence>
+- **Confidence Reasoning:** <confidenceReasoning>
+
+### Fix Information (if available)
+- **Short Link:** <shortLink>
+- **Description:** <suggestedFixDescription>
+- **Reasoning:** <suggestedFixReasoning>
+
+### Task Output Summary (first page)
+<taskOutputSummary>
+[MORE_CONTENT_AVAILABLE: taskOutputSummary, pageToken: 1]
+
+### Suggested Fix (first page)
+<suggestedFix>
+[MORE_CONTENT_AVAILABLE: suggestedFix, pageToken: 1]
+```
+
+### Pagination Indicators
+
+When a heavy field has more content available, append indicator:
+
+```
+[MORE_CONTENT_AVAILABLE: <fieldName>, pageToken: <nextPage>]
+```
+
+Main agent can fetch additional pages if needed using:
+
+```
+ci_information({ select: "<fieldName>", pageToken: <nextPage> })
+```
+
+Fields that may have pagination:
+
+- `taskOutputSummary` (reverse pagination - page 0 = most recent)
+- `suggestedFix` (forward pagination - page 0 = start)
+- `suggestedFixReasoning`
+
+### Return Format for `no_new_cipe`
+
+When returning with `status: no_new_cipe`, include additional context:
+
+```
+## CI Monitor Result
+
+**Status:** no_new_cipe
+**Iterations:** <count>
+**Elapsed:** <minutes>m <seconds>s
+
+### Expected CI Attempt Not Found
+- **Expected Commit SHA:** <expectedCommitSha>
+- **Previous CI Attempt URL:** <previousCipeUrl>
+- **Last Seen CI Attempt URL:** <cipeUrl>
+- **Last Seen Commit SHA:** <commitSha>
+- **New CI Attempt Timeout:** 30 minutes (exceeded)
+
+### Likely Cause
+CI workflow failed before Nx tasks could run (e.g., install step, checkout, auth).
+Check your CI provider logs for the commit <expectedCommitSha>.
+
+### Last Known CI Attempt State
+- **Status:** <cipeStatus>
+- **Branch:** <branch>
+```
+
+## Status Reporting (Verbosity-Controlled)
+
+Output is controlled by the `verbosity` parameter from the main agent:
+
+| Level     | What to Output                                                    |
+| --------- | ----------------------------------------------------------------- |
+| `minimal` | No intermediate output. Only return final result when actionable. |
+| `medium`  | Output only on significant state changes (not every poll).        |
+| `verbose` | Output detailed phase information after every poll.               |
+
+### Minimal Verbosity
+
+No output during polling. Poll silently and return when done.
+
+### Medium Verbosity (Default)
+
+Output **only when state changes significantly** to save context tokens:
+
+- `cipeStatus` changes (e.g., IN_PROGRESS → FAILED)
+- `selfHealingStatus` changes (e.g., IN_PROGRESS → COMPLETED)
+- New CI Attempt detected (in wait mode)
+
+Format: single line, no decorators:
+
+```
+[CI Monitor] CI: FAILED | Self-Healing: IN_PROGRESS | Elapsed: 4m
+```
+
+### Verbose Verbosity
+
+Output detailed phase box after every poll:
+
+```
+[CI Monitor] ─────────────────────────────────────────────────────
+[CI Monitor] Iteration <N> | Elapsed: <X>m <Y>s
+[CI Monitor]
+[CI Monitor] CI Status:          <cipeStatus>
+[CI Monitor] Self-Healing:       <selfHealingStatus>
+[CI Monitor] Verification:       <verificationStatus>
+[CI Monitor] Classification:     <failureClassification>
+[CI Monitor]
+[CI Monitor] → <human-readable phase description>
+[CI Monitor] ─────────────────────────────────────────────────────
+```
+
+### Phase Descriptions (for verbose output)
+
+| Status Combo                                                                              | Description                                 |
+| ----------------------------------------------------------------------------------------- | ------------------------------------------- |
+| `cipeStatus: IN_PROGRESS`                                                                 | "CI running..."                             |
+| `cipeStatus: NOT_STARTED`                                                                 | "Waiting for CI to start..."                |
+| `cipeStatus: FAILED` + `selfHealingStatus: NOT_STARTED`                                   | "CI failed. Self-healing starting..."       |
+| `cipeStatus: FAILED` + `selfHealingStatus: IN_PROGRESS`                                   | "CI failed. Self-healing generating fix..." |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: IN_PROGRESS` | "Fix generated! Verification running..."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: COMPLETED`   | "Fix ready! Verified successfully."         |
+| `cipeStatus: FAILED` + `selfHealingStatus: COMPLETED` + `verificationStatus: FAILED`      | "Fix generated but verification failed."    |
+| `cipeStatus: FAILED` + `selfHealingStatus: FAILED`                                        | "Self-healing could not generate a fix."    |
+| `cipeStatus: SUCCEEDED`                                                                   | "CI passed!"                                |
+
+## Important Notes
+
+- You do NOT make apply/reject decisions - that's the main agent's job
+- You do NOT perform git operations
+- You only poll and report state
+- Respect the `verbosity` parameter for output (default: medium)
+- If `ci_information` returns an error, wait and retry (count as failed poll)
+- Track consecutive failures - if 5 consecutive failures, return with `status: error`
+- When expecting new CI Attempt, track the 30-minute new-CI-Attempt timeout separately from the main polling timeout

.opencode/commands/ci-monitor.md

@@ -0,0 +1,437 @@
+---
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+argument-hint: '[instructions] [--max-cycles N] [--timeout MINUTES] [--verbosity minimal|medium|verbose] [--branch BRANCH] [--fresh] [--auto-fix-workflow] [--new-cipe-timeout MINUTES]'
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+$ARGUMENTS
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `$ARGUMENTS` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.opencode/skills/ci-monitor/SKILL.md

@@ -0,0 +1,437 @@
+---
+name: ci-monitor
+description: Monitor Nx Cloud CI pipeline and handle self-healing fixes automatically. Checks for Nx Cloud connection before starting.
+---
+
+# 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.
+
+## Context
+
+- **Current Branch:** !`git branch --show-current`
+- **Current Commit:** !`git rev-parse --short HEAD`
+- **Remote Status:** !`git status -sb | head -1`
+
+## User Instructions
+
+$ARGUMENTS
+
+**Important:** If user provides specific instructions, respect them over default behaviors described below.
+
+## Configuration Defaults
+
+| Setting                   | Default       | Description                                                         |
+| ------------------------- | ------------- | ------------------------------------------------------------------- |
+| `--max-cycles`            | 10            | Maximum CIPE cycles before timeout                                  |
+| `--timeout`               | 120           | Maximum duration in minutes                                         |
+| `--verbosity`             | medium        | Output level: minimal, medium, verbose                              |
+| `--branch`                | (auto-detect) | Branch to monitor                                                   |
+| `--subagent-timeout`      | 60            | Subagent polling timeout in minutes                                 |
+| `--fresh`                 | false         | Ignore previous context, start fresh                                |
+| `--auto-fix-workflow`     | false         | Attempt common fixes for pre-CIPE failures (e.g., lockfile updates) |
+| `--new-cipe-timeout`      | 10            | Minutes to wait for new CIPE after action                           |
+| `--local-verify-attempts` | 3             | Max local verification + enhance cycles before pushing to CI        |
+
+Parse any overrides from `$ARGUMENTS` and merge with defaults.
+
+## 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
+
+## 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`, Claude remembers the previous state and may continue from where it left off.
+
+- **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`
+
+## 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.
+
+| Status              | Default Behavior                                                                                                                                                  |
+| ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ci_success`        | Exit with success. Log "CI passed successfully!"                                                                                                                  |
+| `fix_auto_applying` | Fix will be auto-applied by self-healing. Do NOT call MCP. Record `last_cipe_url`, spawn new subagent in wait mode to poll for new CIPE.                          |
+| `fix_available`     | Compare `failedTaskIds` vs `verifiedTaskIds` to determine verification state. See **Fix Available Decision Logic** section below.                                 |
+| `fix_failed`        | Self-healing failed to generate fix. Attempt local fix based on `taskOutputSummary`. If successful → commit, push, loop. If not → exit with failure.              |
+| `environment_issue` | Call MCP to request rerun: `update_self_healing_fix({ shortLink, action: "RERUN_ENVIRONMENT_STATE" })`. New CIPE spawns automatically. Loop to poll for new CIPE. |
+| `no_fix`            | CI failed, no fix available (self-healing disabled or not executable). Attempt local fix if possible. Otherwise exit with failure.                                |
+| `no_new_cipe`       | Expected CIPE never spawned (CI workflow likely failed before Nx tasks). Report to user, attempt common fixes if configured, or exit with guidance.               |
+| `polling_timeout`   | Subagent polling timeout reached. Exit with timeout.                                                                                                              |
+| `cipe_canceled`     | CIPE was canceled. Exit with canceled status.                                                                                                                     |
+| `cipe_timed_out`    | CIPE timed out. Exit with timeout status.                                                                                                                         |
+| `error`             | Increment `no_progress_count`. If >= 3 → exit with circuit breaker. Otherwise wait 60s and loop.                                                                  |
+
+### Fix Available Decision Logic
+
+When subagent returns `fix_available`, main agent compares `failedTaskIds` vs `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
+
+| Condition                               | Path                                     |
+| --------------------------------------- | ---------------------------------------- |
+| No unverified tasks (all verified)      | Apply via MCP                            |
+| Unverified tasks exist, but ALL are e2e | Apply via MCP (treat as verified enough) |
+| Verifiable tasks exist                  | Local verification flow                  |
+
+#### 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:**
+
+| Result                    | Action                       |
+| ------------------------- | ---------------------------- |
+| ALL verifiable tasks pass | Apply via MCP                |
+| ANY verifiable task fails | Apply-locally + enhance flow |
+
+4. **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
+
+5. **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
+
+```bash
+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` is `FAILED`, `NOT_EXECUTABLE`, or fix has `couldAutoApplyTasks != true` with no verification:
+
+- 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` field indicates whether the fix is eligible for automatic application:
+
+- **`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`, do NOT call MCP to apply - self-healing handles it. Just spawn a new subagent in wait mode.
+
+### 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`, NOT reject):
+
+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:
+   ```bash
+   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:
+   ```bash
+   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:
+     ```bash
+     pnpm install   # or npm install / yarn install
+     ```
+   - If lockfile changed:
+     ```bash
+     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
+
+## Exit Conditions
+
+Exit the monitoring loop when ANY of these conditions are met:
+
+| Condition                                   | Exit Type        |
+| ------------------------------------------- | ---------------- |
+| CI passes (`cipeStatus == 'SUCCEEDED'`)     | Success          |
+| Max CIPE cycles reached                     | Timeout          |
+| Max duration reached                        | Timeout          |
+| 3 consecutive no-progress iterations        | Circuit breaker  |
+| No fix available and local fix not possible | Failure          |
+| No new CIPE and auto-fix not configured     | Pre-CIPE failure |
+| User cancels                                | Cancelled        |
+
+## 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` subagent to poll CI status:
+
+**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:
+
+| Action                        | What to Track                                 | Subagent Mode |
+| ----------------------------- | --------------------------------------------- | ------------- |
+| Fix auto-applying             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply via MCP                 | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| Apply locally + push          | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Reject + fix + push           | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Fix failed + local fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| No fix + local fix + push     | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+| Environment rerun             | `last_cipe_url = current cipeUrl`             | Wait mode     |
+| No-new-CIPE + auto-fix + push | `expected_commit_sha = $(git rev-parse HEAD)` | Wait mode     |
+
+**CRITICAL**: When passing `expectedCommitSha` or `last_cipe_url` to the subagent, it enters **wait mode**:
+
+- 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`
+
+## Status Reporting
+
+Based on verbosity level:
+
+| Level     | What to Report                                                             |
+| --------- | -------------------------------------------------------------------------- |
+| `minimal` | Only final result (success/failure/timeout)                                |
+| `medium`  | State changes + periodic updates ("Cycle N \| Elapsed: Xm \| Status: ...") |
+| `verbose` | All of medium + full subagent responses, git outputs, MCP responses        |
+
+## User Instruction Examples
+
+Users can override default behaviors:
+
+| Instruction                                      | Effect                                        |
+| ------------------------------------------------ | --------------------------------------------- |
+| "never auto-apply"                               | Always prompt before applying any fix         |
+| "always ask before git push"                     | Prompt before each push                       |
+| "reject any fix for e2e tasks"                   | Auto-reject if `failedTaskIds` contains e2e   |
+| "apply all fixes regardless of verification"     | Skip verification check, apply everything     |
+| "if confidence < 70, reject"                     | Check confidence field before applying        |
+| "run 'nx affected -t typecheck' before applying" | Add local verification step                   |
+| "auto-fix workflow failures"                     | Attempt lockfile updates on pre-CIPE failures |
+| "wait 45 min for new CIPE"                       | Override new-CIPE timeout (default: 10 min)   |
+
+## Error Handling
+
+| Error                    | Action                                                                                |
+| ------------------------ | ------------------------------------------------------------------------------------- |
+| Git rebase conflict      | Report to user, exit                                                                  |
+| `nx apply-locally` fails | Report to user, attempt manual patch or exit                                          |
+| MCP tool error           | Retry once, if fails report to user                                                   |
+| Subagent spawn failure   | Retry once, if fails exit with error                                                  |
+| No new CIPE detected     | If `--auto-fix-workflow`, try lockfile update; otherwise report to user with guidance |
+| Lockfile auto-fix fails  | Report to user, exit with guidance to check CI logs                                   |
+
+## 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
+```

.opencode/skills/nx-generate/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: nx-generate
+description: Generate code using nx generators. USE WHEN scaffolding code or transforming existing code - for example creating libraries or applications, or anything else that is boilerplate code or automates repetitive tasks. ALWAYS use this first when generating code with Nx instead of calling MCP tools or running nx generate immediately.
+---
+
+# Run Nx Generator
+
+Nx generators are powerful tools that scaffold projects, make automated code migrations or automate repetitive tasks in a monorepo. They ensure consistency across the codebase and reduce boilerplate work.
+
+This skill applies when the user wants to:
+
+- Create new projects like libraries or applications
+- Scaffold features or boilerplate code
+- Run workspace-specific or custom generators
+- Do anything else that an nx generator exists for
+
+## Generator Discovery Flow
+
+### Step 1: List Available Generators
+
+Use the Nx CLI to discover available generators:
+
+- List all generators for a plugin: `npx nx list @nx/react`
+- View available plugins: `npx nx list`
+
+This includes:
+
+- Plugin generators (e.g., `@nx/react:library`, `@nx/js:library`)
+- Local workspace generators (defined in the repo's own plugins)
+
+### Step 2: Match Generator to User Request
+
+Based on the user's request, identify which generator(s) could fulfill their needs. Consider:
+
+- What artifact type they want to create (library, application, etc.)
+- Which framework or technology stack is relevant
+- Whether they mentioned specific generator names
+
+**IMPORTANT**: When both a local workspace generator and an external plugin generator could satisfy the request, **always prefer the local workspace generator**. Local generators are customized for the specific repo's patterns and conventions.
+
+It's possible that the user request is something that no Nx generator exists for whatsoever. In this case, you can stop using this skill and try to help the user another way. HOWEVER, the burden of proof for this is high. Before aborting, carefully consider each and every generator that's available. Look into details for any that could be related in any way before making this decision.
+
+## Pre-Execution Checklist
+
+Before running any generator, complete these steps:
+
+### 1. Fetch Generator Schema
+
+Use the `--help` flag to understand all available options:
+
+```bash
+npx nx g @nx/react:library --help
+```
+
+Pay attention to:
+
+- Required options that must be provided
+- Optional options that may be relevant to the user's request
+- Default values that might need to be overridden
+
+### 2. Read Generator Source Code
+
+Understanding what the generator actually does helps you:
+
+- Know what files will be created/modified
+- Understand any side effects (updating configs, installing deps, etc.)
+- Identify options that might not be obvious from the schema
+
+To find generator source code:
+
+- For plugin generators: Use `node -e "console.log(require.resolve('@nx/<plugin>/generators.json'));"` to find the generators.json, then locate the source from there
+- If that fails, read directly from `node_modules/<plugin>/generators.json`
+- For local generators: They are typically in `tools/generators/` or a local plugin directory. You can search the repo for the generator name to find it.
+
+### 2.5 Reevaluate if the generator is right
+
+Once you have built up an understanding of what the selected generator does, reconsider: Is this the right generator to service the user request?
+If not, it's okay to go back to the Generator Discovery Flow and select a different generator before proceeding. If you do, make sure to go through the entire pre-execution checklist once more.
+
+### 3. Understand Repo Context
+
+Before generating, examine the target area of the codebase:
+
+- Look at similar existing artifacts (other libraries, applications, etc.)
+- Identify patterns and conventions used in the repo
+- Note naming conventions, file structures, and configuration patterns
+- Try to match these patterns when configuring the generator
+
+For example, if similar libraries are using a specific test runner, build tool or linter, try to match that if possible.
+If projects or other artifacts are organized with a specific naming convention, try to match it.
+
+### 4. Validate Required Options
+
+Ensure all required options have values:
+
+- Map the user's request to generator options
+- Infer values from context where possible
+- Ask the user for any critical missing information
+
+## Execution
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally.
+Many generators will behave differently based on where they are executed. For example, first-party nx library generators use the cwd to determine the directory that the library should be placed in. This is highly important.
+
+### Consider Dry-Run (Optional)
+
+Running with `--dry-run` first is strongly encouraged but not mandatory. Use your judgment:
+
+- For complex generators or unfamiliar territory: do a dry-run first
+- For simple, well-understood generators: may proceed directly
+- Dry-run shows file names and created/deleted/modified markers, but not content
+- There are cases where a generator does not support dry-run (for example if it had to install an npm package) - in that case --dry-run might fail. Don't be discouraged but simply move on to running the generator for real and iterating from there.
+
+### Running the Generator
+
+Execute the generator with:
+
+```bash
+nx generate <generator-name> <options> --no-interactive
+```
+
+**CRITICAL**: Always include `--no-interactive` to prevent prompts that would hang the execution.
+
+Example:
+
+```bash
+nx generate @nx/react:library --name=my-utils --no-interactive
+```
+
+### Handling Generator Failures
+
+If the generator fails:
+
+1. **Diagnose the error** - Read the error message carefully
+2. **Identify the cause** - Missing options, invalid values, conflicts, etc.
+3. **Attempt automatic fix** - Adjust options or resolve conflicts
+4. **Retry** - Run the generator again with corrected options
+
+Common failure reasons:
+
+- Missing required options
+- Invalid option values
+- Conflicting with existing files
+- Missing dependencies
+- Generator doesn't support certain flag combinations
+
+## Post-Generation
+
+### 1. Modify Generated Code (If Needed)
+
+Generators provide a starting point, but the output may need adjustment to match the user's specific requirements:
+
+- Add or modify functionality as requested
+- Adjust imports, exports, or configurations
+- Integrate with existing code patterns in the repo
+
+### 2. Format Code
+
+Run formatting on all generated/modified files:
+
+```bash
+nx format --fix
+```
+
+Languages other than javascript/typescript might need other formatting invocations too.
+
+### 3. Run Verification
+
+Verify that the generated code works correctly. What this looks like will vary depending on the type of generator and the targets available.
+If the generator created a new project, run its targets directly
+Use your best judgement to determine what needs to be verified.
+
+Example:
+
+```bash
+nx lint <new-project>
+nx test <new-project>
+nx build <new-project>
+```
+
+### 4. Handle Verification Failures
+
+When verification fails:
+
+**If scope is manageable** (a few lint errors, minor type issues):
+
+- Fix the issues
+- Re-run verification to confirm
+
+**If issues are extensive** (many errors, complex problems):
+
+- Attempt simple, obvious fixes first
+- If still failing, escalate to the user with:
+  - Description of what was generated
+  - What verification is failing
+  - What you've attempted to fix
+  - Remaining issues that need user input
+
+## Error Handling
+
+### Generator Failures
+
+- Check the error message for specific causes
+- Verify all required options are provided
+- Check for conflicts with existing files
+- Ensure the generator name and options are correct
+
+### Missing Options
+
+- Consult the generator schema for required fields
+- Infer values from context when reasonable
+- Ask the user for values that cannot be inferred
+
+## Key Principles
+
+1. **Local generators first** - Always prefer workspace/local generators over external plugin generators when both could work
+
+2. **Understand before running** - Read both the schema AND the source code to fully understand what will happen
+
+3. **No prompts** - Always use `--no-interactive` to prevent hanging
+
+4. **Generators are starting points** - Modify the output as needed to fully satisfy the user's requirements
+
+5. **Verify changes work** - Don't just generate; ensure the code builds, lints, and tests pass
+
+6. **Be proactive about fixes** - Don't just report errors; attempt to resolve them automatically when possible
+
+7. **Match repo patterns** - Study existing similar code in the repo and match its conventions

.opencode/skills/nx-plugins/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: nx-plugins
+description: Find and add Nx plugins. USE WHEN user wants to discover available plugins, install a new plugin, or add support for a specific framework or technology to the workspace.
+---
+
+## Finding and Installing new plugins
+
+- List plugins: `pnpm nx list`
+- Install plugins `pnpm nx add <plugin>`. Example: `pnpm nx add @nx/react`.

.opencode/skills/nx-run-tasks/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: nx-run-tasks
+description: Helps with running tasks in an Nx workspace. USE WHEN the user wants to execute build, test, lint, serve, or run any other tasks defined in the workspace.
+---
+
+You can run tasks with Nx in the following way.
+
+Keep in mind that you might have to prefix things with npx/pnpx/yarn if the user doesn't have nx installed globally. Look at the package.json or lockfile to determine which package manager is in use.
+
+For more details on any command, run it with `--help` (e.g. `nx run-many --help`, `nx affected --help`).
+
+## Understand which tasks can be run
+
+You can check those via `nx show project <projectname> --json`, for example `nx show project myapp --json`. It contains a `targets` section which has information about targets that can be run. You can also just look at the `package.json` scripts or `project.json` targets, but you might miss out on inferred tasks by Nx plugins.
+
+## Run a single task
+
+```
+nx run <project>:<task>
+```
+
+where `project` is the project name defined in `package.json` or `project.json` (if present).
+
+## Run multiple tasks
+
+```
+nx run-many -t build test lint typecheck
+```
+
+You can pass a `-p` flag to filter to specific projects, otherwise it runs on all projects. You can also use `--exclude` to exclude projects, and `--parallel` to control the number of parallel processes (default is 3).
+
+Examples:
+
+- `nx run-many -t test -p proj1 proj2` — test specific projects
+- `nx run-many -t test --projects=*-app --exclude=excluded-app` — test projects matching a pattern
+- `nx run-many -t test --projects=tag:api-*` — test projects by tag
+
+## Run tasks for affected projects
+
+Use `nx affected` to only run tasks on projects that have been changed and projects that depend on changed projects. This is especially useful in CI and for large workspaces.
+
+```
+nx affected -t build test lint
+```
+
+By default it compares against the base branch. You can customize this:
+
+- `nx affected -t test --base=main --head=HEAD` — compare against a specific base and head
+- `nx affected -t test --files=libs/mylib/src/index.ts` — specify changed files directly
+
+## Useful flags
+
+These flags work with `run`, `run-many`, and `affected`:
+
+- `--skipNxCache` — rerun tasks even when results are cached
+- `--verbose` — print additional information such as stack traces
+- `--nxBail` — stop execution after the first failed task
+- `--configuration=<name>` — use a specific configuration (e.g. `production`)

.opencode/skills/nx-workspace/SKILL.md

@@ -0,0 +1,186 @@
+---
+name: nx-workspace
+description: "Explore and understand Nx workspaces. USE WHEN answering any questions about the nx workspace, the projects in it or tasks to run. EXAMPLES: 'What projects are in this workspace?', 'How is project X configured?', 'What targets can I run?', 'What's affected by my changes?', 'Which projects depend on library Y?', or any questions about Nx workspace structure, project configuration, or available tasks."
+---
+
+# Nx Workspace Exploration
+
+This skill provides read-only exploration of Nx workspaces. Use it to understand workspace structure, project configuration, available targets, and dependencies.
+
+Keep in mind that you might have to prefix commands with `npx`/`pnpx`/`yarn` if nx isn't installed globally. Check the lockfile to determine the package manager in use.
+
+## Listing Projects
+
+Use `nx show projects` to list projects in the workspace.
+
+```bash
+# List all projects
+nx show projects
+
+# Filter by pattern (glob)
+nx show projects --projects "apps/*"
+nx show projects --projects "shared-*"
+
+# Filter by project type
+nx show projects --type app
+nx show projects --type lib
+nx show projects --type e2e
+
+# Filter by target (projects that have a specific target)
+nx show projects --withTarget build
+nx show projects --withTarget e2e
+
+# Find affected projects (changed since base branch)
+nx show projects --affected
+nx show projects --affected --base=main
+nx show projects --affected --type app
+
+# Combine filters
+nx show projects --type lib --withTarget test
+nx show projects --affected --exclude="*-e2e"
+
+# Output as JSON
+nx show projects --json
+```
+
+## Project Configuration
+
+Use `nx show project <name> --json` to get the full resolved configuration for a project.
+
+**Important**: Do NOT read `project.json` directly - it only contains partial configuration. The `nx show project` command returns the full resolved config including inferred targets from plugins.
+
+You can read the full project schema at `node_modules/nx/schemas/project-schema.json` to understand nx project configuration options.
+
+```bash
+# Get full project configuration
+nx show project my-app --json
+
+# Extract specific parts from the JSON
+nx show project my-app --json | jq '.targets'
+nx show project my-app --json | jq '.targets.build'
+nx show project my-app --json | jq '.targets | keys'
+
+
+# Check project metadata
+nx show project my-app --json | jq '{name, root, sourceRoot, projectType, tags}'
+```
+
+## Target Information
+
+Targets define what tasks can be run on a project.
+
+```bash
+# List all targets for a project
+nx show project my-app --json | jq '.targets | keys'
+
+# Get full target configuration
+nx show project my-app --json | jq '.targets.build'
+
+# Check target executor/command
+nx show project my-app --json | jq '.targets.build.executor'
+nx show project my-app --json | jq '.targets.build.command'
+
+# View target options
+nx show project my-app --json | jq '.targets.build.options'
+
+# Check target inputs/outputs (for caching)
+nx show project my-app --json | jq '.targets.build.inputs'
+nx show project my-app --json | jq '.targets.build.outputs'
+
+# Find projects with a specific target
+nx show projects --withTarget serve
+nx show projects --withTarget e2e
+```
+
+## Workspace Configuration
+
+Read `nx.json` directly for workspace-level configuration.
+You can read the full project schema at `node_modules/nx/schemas/nx-schema.json` to understand nx project configuration options.
+
+```bash
+# Read the full nx.json
+cat nx.json
+
+# Or use jq for specific sections
+cat nx.json | jq '.targetDefaults'
+cat nx.json | jq '.namedInputs'
+cat nx.json | jq '.plugins'
+cat nx.json | jq '.generators'
+```
+
+Key nx.json sections:
+
+- `targetDefaults` - Default configuration applied to all targets of a given name
+- `namedInputs` - Reusable input definitions for caching
+- `plugins` - Nx plugins and their configuration
+- ...and much more, read the schema or nx.json for details
+
+## Affected Projects
+
+Find projects affected by changes in the current branch.
+
+```bash
+# Affected since base branch (auto-detected)
+nx show projects --affected
+
+# Affected with explicit base
+nx show projects --affected --base=main
+nx show projects --affected --base=origin/main
+
+# Affected between two commits
+nx show projects --affected --base=abc123 --head=def456
+
+# Affected apps only
+nx show projects --affected --type app
+
+# Affected excluding e2e projects
+nx show projects --affected --exclude="*-e2e"
+
+# Affected by uncommitted changes
+nx show projects --affected --uncommitted
+
+# Affected by untracked files
+nx show projects --affected --untracked
+```
+
+## Common Exploration Patterns
+
+### "What's in this workspace?"
+
+```bash
+nx show projects
+nx show projects --type app
+nx show projects --type lib
+```
+
+### "How do I build/test/lint project X?"
+
+```bash
+nx show project X --json | jq '.targets | keys'
+nx show project X --json | jq '.targets.build'
+```
+
+### "What depends on library Y?"
+
+```bash
+# Find projects that may depend on Y by searching for imports
+# (Nx doesn't have a direct "dependents" command via CLI)
+grep -r "from '@myorg/Y'" --include="*.ts" --include="*.tsx" apps/ libs/
+```
+
+### "What configuration options are available?"
+
+```bash
+cat node_modules/nx/schemas/nx-schema.json | jq '.properties | keys'
+cat node_modules/nx/schemas/project-schema.json | jq '.properties | keys'
+```
+
+### "Why is project X affected?"
+
+```bash
+# Check what files changed
+git diff --name-only main
+
+# See which project owns those files
+nx show project X --json | jq '.root'
+```

.prettierignore

@@ -54,3 +54,8 @@ _solution
 
 # this file uses TS import attributes which the current prettier version does not support
 tools/documentation/create-embeddings/src/main.mts
+
+.nx/self-healing
+
+# Inlined from `@yarnpkg/parser` keep as is
+packages/nx/src/utils/yarn-syml/syml-grammar.js

AGENTS.md

@@ -86,6 +86,16 @@ If the prepush validation suite fails, please fix the issues before proceeding w
 code adheres to the project's standards and passes all tests. DO NOT make a new commit to fix these issues. Instead,
 amend the current commit.
 
+### Testing Changes in Other Repos
+
+To test a locally built Nx package in another repository (e.g., to verify a fix end-to-end):
+
+```bash
+pnpm copy-built-package --package nx --repo ../path/to/test-repo
+```
+
+This builds the package and copies it into the target repo's `node_modules`. It works for all packages including native Rust code.
+
 ### Testing Changes
 
 After code changes are made, first test the specific project where the changes were made:
@@ -202,22 +212,23 @@ Fixes #ISSUE_NUMBER
 <!-- nx configuration start-->
 <!-- Leave the start & end comments to automatically receive updates. -->
 
-# General Guidelines for working with Nx
+## General Guidelines for working with Nx
 
+- For navigating/exploring the workspace, invoke the `nx-workspace` skill first - it has patterns for querying projects, targets, and dependencies
 - When running tasks (for example build, lint, test, e2e, etc.), always prefer running the task through `nx` (i.e. `nx run`, `nx run-many`, `nx affected`) instead of using the underlying tooling directly
+- Prefix nx commands with the workspace's package manager (e.g., `pnpm nx build`, `npm exec nx test`) - avoids using globally installed CLI
 - You have access to the Nx MCP server and its tools, use them to help the user
-- When answering questions about the repository, use the `nx_workspace` tool first to gain an understanding of the workspace architecture where applicable.
-- When working in individual projects, use the `nx_project_details` mcp tool to analyze and understand the specific project structure and dependencies
-- For questions around nx configuration, best practices or if you're unsure, use the `nx_docs` tool to get relevant, up-to-date docs. Always use this instead of assuming things about nx configuration
-- If the user needs help with an Nx configuration or project graph error, use the `nx_workspace` tool to get any errors
+- For Nx plugin best practices, check `node_modules/@nx/<plugin>/PLUGIN.md`. Not all plugins have this file - proceed without it if unavailable.
+- NEVER guess CLI flags - always check nx_docs or `--help` first when unsure
 
-# CI Error Guidelines
+## Scaffolding & Generators
 
-If the user wants help with fixing an error in their CI pipeline, use the following flow:
+- For scaffolding tasks (creating apps, libs, project structure, setup), ALWAYS invoke the `nx-generate` skill FIRST before exploring or calling MCP tools
 
-- Retrieve the list of current CI Pipeline Executions (CIPEs) using the `nx_cloud_cipe_details` tool
-- If there are any errors, use the `nx_cloud_fix_cipe_failure` tool to retrieve the logs for a specific task
-- Use the task logs to see what's wrong and help the user fix their problem. Use the appropriate tools if necessary
-- Make sure that the problem is fixed by running the task that you passed into the `nx_cloud_fix_cipe_failure` tool
+## When to use nx_docs
+
+- USE for: advanced config options, unfamiliar flags, migration guides, plugin configuration, edge cases
+- DON'T USE for: basic generator syntax (`nx g @nx/react:app`), standard commands, things you already know
+- The `nx-generate` skill handles generator discovery internally - don't call nx_docs just to look up generator syntax
 
 <!-- nx configuration end-->

CLAUDE.md

@@ -21,6 +21,8 @@ When working on Nx documentation, all documentation content lives in the `astro-
 - Development workflow and commands
 - Sidebar management
 
+**MANDATORY**: After editing any file in `astro-docs/src/content/`, run the `nx-docs-style-check` skill. No exceptions.
+
 ### Quick Reference
 
 - Documentation content: `astro-docs/src/content/docs/`
@@ -202,22 +204,23 @@ Fixes #ISSUE_NUMBER
 <!-- nx configuration start-->
 <!-- Leave the start & end comments to automatically receive updates. -->
 
-# General Guidelines for working with Nx
+## General Guidelines for working with Nx
 
+- For navigating/exploring the workspace, invoke the `nx-workspace` skill first - it has patterns for querying projects, targets, and dependencies
 - When running tasks (for example build, lint, test, e2e, etc.), always prefer running the task through `nx` (i.e. `nx run`, `nx run-many`, `nx affected`) instead of using the underlying tooling directly
+- Prefix nx commands with the workspace's package manager (e.g., `pnpm nx build`, `npm exec nx test`) - avoids using globally installed CLI
 - You have access to the Nx MCP server and its tools, use them to help the user
-- When answering questions about the repository, use the `nx_workspace` tool first to gain an understanding of the workspace architecture where applicable.
-- When working in individual projects, use the `nx_project_details` mcp tool to analyze and understand the specific project structure and dependencies
-- For questions around nx configuration, best practices or if you're unsure, use the `nx_docs` tool to get relevant, up-to-date docs. Always use this instead of assuming things about nx configuration
-- If the user needs help with an Nx configuration or project graph error, use the `nx_workspace` tool to get any errors
+- For Nx plugin best practices, check `node_modules/@nx/<plugin>/PLUGIN.md`. Not all plugins have this file - proceed without it if unavailable.
+- NEVER guess CLI flags - always check nx_docs or `--help` first when unsure
 
-# CI Error Guidelines
+## Scaffolding & Generators
 
-If the user wants help with fixing an error in their CI pipeline, use the following flow:
+- For scaffolding tasks (creating apps, libs, project structure, setup), ALWAYS invoke the `nx-generate` skill FIRST before exploring or calling MCP tools
 
-- Retrieve the list of current CI Pipeline Executions (CIPEs) using the `nx_cloud_cipe_details` tool
-- If there are any errors, use the `nx_cloud_fix_cipe_failure` tool to retrieve the logs for a specific task
-- Use the task logs to see what's wrong and help the user fix their problem. Use the appropriate tools if necessary
-- Make sure that the problem is fixed by running the task that you passed into the `nx_cloud_fix_cipe_failure` tool
+## When to use nx_docs
+
+- USE for: advanced config options, unfamiliar flags, migration guides, plugin configuration, edge cases
+- DON'T USE for: basic generator syntax (`nx g @nx/react:app`), standard commands, things you already know
+- The `nx-generate` skill handles generator discovery internally - don't call nx_docs just to look up generator syntax
 
 <!-- nx configuration end-->

CODEOWNERS

@@ -1,178 +1,2 @@
 # Any file not covered by a rule below, will default to Jason + Victor and a few select others.
-* @FrozenPandaz @vsavkin
-/packages/**/* @FrozenPandaz @vsavkin @AgentEnder @jaysoo @JamesHenry
-/e2e/**/* @FrozenPandaz @vsavkin @AgentEnder @jaysoo @JamesHenry
-/scripts/**/* @FrozenPandaz @vsavkin @AgentEnder @jaysoo @JamesHenry
-/tools/**/* @FrozenPandaz @vsavkin @AgentEnder @jaysoo @JamesHenry
-package.json @nrwl/nx-core-reviewers
-pnpm-lock.yaml @nrwl/nx-core-reviewers
-rust-toolchain.toml @nrwl/nx-native-reviewers
-
-# Docs Site + Graph
-/astro-docs @nrwl/nx-docs-reviewers
-/docs @nrwl/nx-docs-reviewers
-/graph/** @philipjfulcher @FrozenPandaz @bcabanes @MaxKless @Coly010 @jaysoo @nartc
-/images @nrwl/nx-docs-reviewers
-/nx-dev/** @nrwl/nx-docs-reviewers
-
-# Plugin Verticals
-
-## Angular
-/packages/angular/** @nrwl/nx-angular-reviewers
-/packages/angular-rspack/** @nrwl/nx-angular-reviewers
-/packages/angular-rspack-compiler/** @nrwl/nx-angular-reviewers
-/examples/angular-rspack/** @nrwl/nx-angular-reviewers
-/e2e/angular/** @nrwl/nx-angular-reviewers
-/packages/angular/plugins/component-testing.ts @nrwl/nx-angular-reviewers @nrwl/nx-testing-tools-reviewers
-/packages/angular/src/generators/cypress-component-configuration/** @nrwl/nx-angular-reviewers @nrwl/nx-testing-tools-reviewers
-/packages/angular/src/generators/component-test/** @nrwl/nx-angular-reviewers @nrwl/nx-testing-tools-reviewers
-
-## React
-/packages/react/** @nrwl/nx-react-reviewers
-/e2e/react/** @nrwl/nx-react-reviewers
-/packages/next/** @nrwl/nx-react-reviewers
-/e2e/next/** @nrwl/nx-react-reviewers
-/packages/react/plugins/component-testing/** @nrwl/nx-react-reviewers @nrwl/nx-testing-tools-reviewers
-/packages/react/src/generators/cypress-component-configuration/** @nrwl/nx-react-reviewers @nrwl/nx-testing-tools-reviewers
-/packages/react/src/generators/component-test/** @nrwl/nx-react-reviewers @nrwl/nx-testing-tools-reviewers
-
-# React Native
-/packages/detox/** @nrwl/nx-react-reviewers
-/e2e/detox/** @nrwl/nx-react-reviewers
-/packages/expo/** @nrwl/nx-react-reviewers
-/e2e/expo/** @nrwl/nx-react-reviewers
-/packages/react-native/** @nrwl/nx-react-reviewers
-/e2e/react-native/** @nrwl/nx-react-reviewers
-
-## remix
-/packages/remix/** @nrwl/nx-react-reviewers @Coly010
-/e2e/remix/** @nrwl/nx-react-reviewers @Coly010
-
-# Vue
-/packages/vue/** @nrwl/nx-vue-reviewers
-/e2e/vue/** @nrwl/nx-vue-reviewers
-/packages/nuxt/** @nrwl/nx-vue-reviewers
-/e2e/nuxt/** @nrwl/nx-vue-reviewers
-
-## Node
-/packages/node/** @nrwl/nx-node-reviewers
-/packages/express/** @nrwl/nx-node-reviewers
-/packages/nest/** @nrwl/nx-node-reviewers
-/e2e/node/** @nrwl/nx-node-reviewers
-
-## JS
-/packages/js/** @nrwl/nx-js-reviewers
-/e2e/js/** @nrwl/nx-js-reviewers
-/packages/web/** @nrwl/nx-js-reviewers
-/e2e/web/** @nrwl/nx-js-reviewers
-/packages/webpack/** @nrwl/nx-js-reviewers
-/e2e/webpack/** @nrwl/nx-js-reviewers
-/packages/rspack/** @nrwl/nx-js-reviewers
-/e2e/rspack/** @nrwl/nx-js-reviewers
-/packages/rsbuild/** @nrwl/nx-js-reviewers
-/packages/esbuild/** @nrwl/nx-js-reviewers
-/e2e/esbuild/** @nrwl/nx-js-reviewers
-/packages/rollup/** @nrwl/nx-js-reviewers
-/e2e/rollup/** @nrwl/nx-js-reviewers
-/packages/vite/** @nrwl/nx-js-reviewers
-/e2e/vite/** @nrwl/nx-js-reviewers
-/packages/vitest/** @nrwl/nx-js-reviewers
-
-## Module Federation
-/packages/module-federation/** @nrwl/nx-js-reviewers
-
-## Tools
-/packages/cypress/** @nrwl/nx-testing-tools-reviewers
-/e2e/cypress/** @nrwl/nx-testing-tools-reviewers
-/packages/jest/** @nrwl/nx-testing-tools-reviewers
-/e2e/jest/** @nrwl/nx-testing-tools-reviewers
-/packages/playwright/** @nrwl/nx-testing-tools-reviewers
-/e2e/playwright/** @nrwl/nx-testing-tools-reviewers
-
-# Linter
-/packages/eslint-plugin/** @nrwl/nx-linter-reviewers
-/packages/eslint/** @nrwl/nx-linter-reviewers
-/e2e/eslint/** @nrwl/nx-linter-reviewers
-.eslint* @nrwl/nx-linter-reviewers
-
-# Storybook
-/packages/storybook/** @nrwl/nx-storybook-reviewers
-/e2e/storybook/** @nrwl/nx-storybook-reviewers
-
-# Docker
-/packages/docker/** @nrwl/nx-core-reviewers @Coly010 @jaysoo
-
-## Devkit
-/packages/devkit/** @nrwl/nx-devkit-reviewers
-/packages/devkit/index.ts @FrozenPandaz @vsavkin
-/packages/devkit/public-api.ts @FrozenPandaz @vsavkin
-
-# Gradle
-/packages/gradle/** @FrozenPandaz @MaxKless @lourw
-/e2e/gradle/** @FrozenPandaz @MaxKless @lourw
-/build.gradle.kts @FrozenPandaz @MaxKless @lourw
-/settings.gradle.kts @FrozenPandaz @MaxKless @lourw
-
-# Maven
-/packages/maven/** @FrozenPandaz @MaxKless @lourw
-/e2e/maven/** @FrozenPandaz @MaxKless @lourw
-/pom.xml @FrozenPandaz @MaxKless @lourw
-
-# Nx-Plugin
-/packages/plugin/** @nrwl/nx-devkit-reviewers
-/e2e/plugin/** @nrwl/nx-devkit-reviewers
-/packages/create-nx-plugin/** @nrwl/nx-devkit-reviewers
-
-## Core
-/packages/nx/** @nrwl/nx-core-reviewers
-/packages/nx/src/adapter @nrwl/nx-core-reviewers @leosvelperez
-/packages/nx/src/native @nrwl/nx-core-reviewers @nrwl/nx-native-reviewers
-/packages/nx/src/plugins/js/lock-file @nrwl/nx-core-reviewers @meeroslav
-/packages/nx/src/command-line/init/implementation/angular/** @nrwl/nx-angular-reviewers @nrwl/nx-core-reviewers
-/e2e/nx-init/src/nx-init-angular.test.ts @nrwl/nx-angular-reviewers
-/packages/nx/src/command-line/init/implementation/react/** @nrwl/nx-react-reviewers
-/e2e/nx-init/src/nx-init-react.test.ts @nrwl/nx-react-reviewers
-/e2e/nx-init/src/files/cra/** @nrwl/nx-react-reviewers
-/e2e/nx*/** @nrwl/nx-core-reviewers
-/packages/workspace/** @nrwl/nx-core-reviewers
-/e2e/workspace-create/** @nrwl/nx-core-reviewers
-/packages/create-nx-workspace/** @nrwl/nx-core-reviewers
-/packages/nx/src/command-line/release/** @nrwl/nx-core-reviewers @Coly010
-/packages/nx/src/plugins/js/** @nrwl/nx-core-reviewers @nrwl/nx-js-reviewers
-/e2e/release/** @nrwl/nx-core-reviewers @Coly010
-
-# .NET
-/packages/dotnet/** @FrozenPandaz @AgentEnder
-/e2e/dotnet/** @FrozenPandaz @AgentEnder
-
-# Misc
-/e2e/lerna-smoke-tests/** @vsavkin @JamesHenry
-/e2e/utils/** @meeroslav @nrwl/nx-testing-tools-reviewers @vsavkin
-/CONTRIBUTING.md @FrozenPandaz
-/CODE_OF_CONDUCT.md @FrozenPandaz
-/CODEOWNERS @FrozenPandaz @AgentEnder
-/packages/nx/src/nx-cloud/utilities/url-shorten.ts @MaxKless
-
-# Scripts
-/scripts/documentation @nrwl/nx-docs-reviewers
-/scripts/angular-support-upgrades @nrwl/nx-angular-reviewers
-
-# CI
-/.nx/workflows/** @nrwl/nx-pipelines-reviewers
-mise.toml @nrwl/nx-pipelines-reviewers @FrozenPandaz
-/.github/** @nrwl/nx-pipelines-reviewers
-/.husky/** @nrwl/nx-pipelines-reviewers
-/packages/workspace/src/generators/ci-workflow/** @nrwl/nx-pipelines-reviewers
-
-# AI Agent Integration
-CLAUDE.md @FrozenPandaz @Coly010
-.claude/** @FrozenPandaz @Coly010
-.mcp.json @FrozenPandaz @Coly010
-AGENTS.md @FrozenPandaz @Coly010
-.gemini @FrozenPandaz @Coly010
-
-# Global Files
-project.json @FrozenPandaz @vsavkin
-jest.config.ts @nrwl/nx-testing-tools-reviewers @FrozenPandaz
-jest.preset.js @nrwl/nx-testing-tools-reviewers @FrozenPandaz
-
+* @nrwl/nx-cli-reviewers

CONTRIBUTING.md

@@ -2,19 +2,10 @@
 
 We would love for you to contribute to Nx! Read this document to see how to do it.
 
-## How to Get Started Video
-
-Watch this 5-minute video:
-
-<a href="https://www.youtube.com/watch?v=8LCA_4qxc08" target="_blank" rel="noreferrer">
-<p style="text-align: center;"><img src="./images/how-to-contribute.png" width="600" alt="Nx - How to contribute"></p>
-</a>
-
 ## Got a Question?
 
-We are trying to keep GitHub issues for bug reports and feature requests. Using the `nrwl` tag
-on [Stack Overflow](https://stackoverflow.com/questions/tagged/nrwl) is a much better place to ask general questions
-about how to use Nx.
+We are trying to keep GitHub issues for bug reports and feature requests.
+You can join our [Discord](https://go.nx.dev/community) for general questions and seeking help from others.
 
 ## Found an Issue?
 

Directory.Build.props

@@ -0,0 +1,5 @@
+<Project>
+  <PropertyGroup>
+    <UseSharedCompilation>false</UseSharedCompilation>
+  </PropertyGroup>
+</Project>

LICENSE

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2017-2025 Narwhal Technologies Inc.
+Copyright (c) 2017-2026 Narwhal Technologies Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,76 +1,52 @@
-<p style="text-align: center;">
- <picture>
- <source media="(prefers-color-scheme: dark)" srcset="./images/nx-dark.svg">
- <img alt="Nx - Smart Repos · Fast Builds" src="./images/nx-light.svg" width="100%">
- </picture>
-</p>
+<div align="center">
 
-<div style="text-align: center;">
+  <p>
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="images/nx-logo-light.svg">
+      <img src="images/nx-logo.svg" alt="Nx Logo" width="140">
+    </picture>
+  </p>
 
-[![CircleCI](https://circleci.com/gh/nrwl/nx.svg?style=svg)](https://circleci.com/gh/nrwl/nx)
-[![License](https://img.shields.io/npm/l/nx.svg?style=flat-square)]()
-[![NPM Version](https://badge.fury.io/js/nx.svg)](https://www.npmjs.com/package/nx)
-[![Semantic Release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic-release-e10079.svg?style=flat-square)]()
-[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
-[![Join the chat at https://gitter.im/nrwl-nx/community](https://badges.gitter.im/nrwl-nx/community.svg)](https://gitter.im/nrwl-nx/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-[![Join the Official Nx Discord Server](https://img.shields.io/discord/1143497901675401286?label=discord)](https://go.nx.dev/community)
+  <h1 align="center">Smart Monorepos · Fast Builds</h1>
+
+  <p>
+    <a href="https://www.npmjs.com/package/nx"><img src="https://img.shields.io/npm/v/nx.svg?style=for-the-badge" alt="NPM Version"></a>
+    <a href="https://github.com/nrwl/nx"><img src="https://img.shields.io/github/stars/nrwl/nx?style=for-the-badge&logo=github" alt="GitHub Stars"></a>
+    <a href=""><img src="https://img.shields.io/npm/l/nx.svg?style=for-the-badge" alt="License"></a>
+    <a href="https://go.nx.dev/community"><img src="https://img.shields.io/discord/1143497901675401286?label=discord&style=for-the-badge" alt="Discord"></a>
+    <a href="https://x.com/nxdevtools"><img src="https://img.shields.io/badge/@nxdevtools-555?style=for-the-badge&logo=x" alt="X (Twitter)"></a>
+  </p>
+
+ <br />
+
+[**Docs**](https://nx.dev/docs) &nbsp;&bull;&nbsp; [**Changelog**](https://nx.dev/changelog) &nbsp;&bull;&nbsp; [**Blog**](https://nx.dev/blog) &nbsp;&bull;&nbsp; [**Courses**](https://nx.dev/courses) &nbsp;&bull;&nbsp; [**YouTube**](https://youtube.com/@nxdevtools)
+
+<br />
 
 </div>
 
-<!-- delete me -->
+Nx is a monorepo solution for TypeScript and polyglot codebases. Built with Rust for performance, extensible via TypeScript. Caches what didn't change, runs only what's affected, and comes with an integrated CI solution. Start simple, scale as you grow.
 
-<hr>
+## Quick Start
 
-# Smart Repos · Fast Builds
+Visit the [Nx quickstart docs](https://nx.dev/docs/quickstart) to get started.
 
-Get to green PRs in half the time. Nx optimizes your builds, scales your CI, and fixes failed PRs. Built for developers and AI agents.
+## Why Nx?
 
-Create a new Nx workspace with
+- **Incremental by design -** Run `npx nx init` in any npm/pnpm/yarn workspace. Nx picks up your existing `package.json` scripts, caches their outputs, and runs only what's
+  affected. No changes to your setup required.
+- **AI-native tooling -** The Nx CLI is optimized for autonomous AI agents so they get the context they need and can operate just like a human. [Learn more &raquo;](https://github.com/nrwl/nx-ai-agents-config)
+- **Polyglot plugin system -** Optional plugins auto-discover tasks, configure cache inputs/outputs, and scaffold code based on your actual tooling. Works with Vite, Webpack, Jest, Vitest, ESLint, Gradle, Maven, .NET, Go, and [more](https://nx.dev/technologies).
+- **Integrated CI solution -** [Connect Nx to your CI provider](https://nx.dev/ci/intro/ci-with-nx) (GitHub Actions, GitLab, Azure, etc.) to enable remote caching, task distribution across machines, affected-only runs, and automatic e2e test splitting. [Learn more &raquo;](https://nx.dev/ci/intro/ci-with-nx)
+- **Self-healing CI -** An AI agent on your CI pipeline that detects failures, analyzes root cause, proposes a fix, and verifies it automatically. Local agents connect to CI via MCP to autonomously detect and fix failures. [Learn more &raquo;](https://nx.dev/ci/features/self-healing)
 
-```shell
-npx create-nx-workspace
-```
+## Who uses Nx?
 
-...or run
-
-```
-npx nx init
-```
-
-to add Nx to your existing workspace to get faster task scheduling, caching and more. More [in the docs](https://nx.dev/getting-started/intro).
-
-## Learn about CI with Nx Cloud
-
-[Nx Cloud](https://nx.dev/nx-cloud) connects directly to your existing CI setup, helping you scale your monorepos on CI by leveraging [remote caching](https://nx.dev/ci/features/remote-cache?utm_source=nxrepo&utm_medium=readme&utm_campaign=nxrepo), [task distribution across multiple machines](https://nx.dev/ci/features/distribute-task-execution?utm_source=nxrepo&utm_medium=readme&utm_campaign=nxrepo), [automated e2e test splitting](https://nx.dev/ci/features/split-e2e-tasks?utm_source=nxrepo&utm_medium=readme&utm_campaign=nxrepo) and [automated task flakiness detection](https://nx.dev/ci/features/flaky-tasks?utm_source=nxrepo&utm_medium=readme&utm_campaign=nxrepo)
-
-Connect your existing Nx workspace with
-
-```
-npx nx connect
-```
-
-Learn more in the [Nx CI docs &raquo;](https://nx.dev/ci/getting-started/intro?utm_source=nxrepo&utm_medium=readme&utm_campaign=nxrepo)
-
-## Useful links
-
-- [Our docs](https://nx.dev/docs)
-- [Our blog](https://nx.dev/blog)
-- [Our community discord, live stream,...](https://nx.dev/community)
-- [Our YouTube channel](https://www.youtube.com/@NxDevtools)
-- [Our Twitter/X](https://x.com/nxdevtools)
-
-<p style="text-align: center;"><a href="https://www.youtube.com/@nxdevtools/videos" target="_blank" rel="noreferrer"><img src="./images/nx-courses-and-videos.svg" 
-width="100%" alt="Nx - Smart Repos · Fast Builds"></a></p>
+From startups to Fortune 500 companies. [See our Nx success stories &raquo;](https://nx.dev/customers)
 
 ## Want to help?
 
-If you want to file a bug or submit a PR, read up on
-our [guidelines for contributing](https://github.com/nrwl/nx/blob/master/CONTRIBUTING.md) and watch this video that will
-help you get started.
-
-<a href="https://www.youtube.com/watch?v=8LCA_4qxc08" target="_blank" rel="noreferrer">
-<p style="text-align: center;"><img src="./images/how-to-contribute.png" width="600" alt="Nx - How to contribute video"></p>
-</a>
+If you want to file a bug or submit a PR, read up on our [guidelines for contributing](https://github.com/nrwl/nx/blob/master/CONTRIBUTING.md).
 
 ## Core Team
 
@@ -84,22 +60,17 @@ help you get started.
 | ![James Henry](https://avatars.githubusercontent.com/u/900523?s=160&v=4) | ![Jon Cammisuli](https://avatars2.githubusercontent.com/u/4332460?s=160) | ![Max Kless](https://avatars.githubusercontent.com/u/34165455?s=160) | ![Juri Strumpflohner](https://avatars1.githubusercontent.com/u/542458?s=160) |
 | [JamesHenry](https://github.com/JamesHenry)                              | [cammisuli](https://github.com/cammisuli)                                | [MaxKless](https://github.com/MaxKless)                              | [juristr](https://github.com/juristr)                                        |
 
-| Philip Fulcher                                                            | Caleb Ukle                                                            | Colum Ferry                                                            | Steven Nance                                                           |
-| ------------------------------------------------------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| ![Philip Fulcher](https://avatars1.githubusercontent.com/u/1536471?s=160) | ![Caleb Ukle](https://avatars.githubusercontent.com/u/23272162?s=160) | ![Colum Ferry](https://avatars.githubusercontent.com/u/12140467?s=160) | ![Steven Nance](https://avatars.githubusercontent.com/u/1036428?s=160) |
-| [philipjfulcher](https://github.com/philipjfulcher)                       | [barbados-clemens](https://github.com/barbados-clemens)               | [Coly010](https://github.com/Coly010)                                  | [llwt](https://github.com/llwt)                                        |
+| Caleb Ukle                                                            | Steven Nance                                                           | Miroslav Jonaš                                                          | Leosvel Pérez Espinosa                                                            |
+| --------------------------------------------------------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- |
+| ![Caleb Ukle](https://avatars.githubusercontent.com/u/23272162?s=160) | ![Steven Nance](https://avatars.githubusercontent.com/u/1036428?s=160) | ![Miroslav Jonaš](https://avatars.githubusercontent.com/u/881612?s=160) | ![Leosvel Pérez Espinosa](https://avatars.githubusercontent.com/u/12051310?s=160) |
+| [barbados-clemens](https://github.com/barbados-clemens)               | [llwt](https://github.com/llwt)                                        | [meeroslav](https://github.com/meeroslav)                               | [leosvelperez](https://github.com/leosvelperez)                                   |
 
-| Miroslav Jonaš                                                          | Leosvel Pérez Espinosa                                                            | Zachary DeRose                                                           | Craigory Coppola                                                           |
-| ----------------------------------------------------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
-| ![Miroslav Jonaš](https://avatars.githubusercontent.com/u/881612?s=160) | ![Leosvel Pérez Espinosa](https://avatars.githubusercontent.com/u/12051310?s=160) | ![Zachary DeRose](https://avatars.githubusercontent.com/u/3788405?s=160) | ![Craigory Coppola](https://avatars.githubusercontent.com/u/6933928?s=160) |
-| [meeroslav](https://github.com/meeroslav)                               | [leosvelperez](https://github.com/leosvelperez)                                   | [ZackDeRose](https://github.com/ZackDeRose)                              | [AgentEnder](https://github.com/AgentEnder)                                |
+| Zachary DeRose                                                           | Craigory Coppola                                                           | Chau Tran                                                            | Nicole Oliver                                                           |
+| ------------------------------------------------------------------------ | -------------------------------------------------------------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------- |
+| ![Zachary DeRose](https://avatars.githubusercontent.com/u/3788405?s=160) | ![Craigory Coppola](https://avatars.githubusercontent.com/u/6933928?s=160) | ![Chau Tran](https://avatars.githubusercontent.com/u/25516557?s=160) | ![Nicole Oliver](https://avatars.githubusercontent.com/u/4440385?s=160) |
+| [ZackDeRose](https://github.com/ZackDeRose)                              | [AgentEnder](https://github.com/AgentEnder)                                | [nartc](https://github.com/nartc)                                    | [nixallover](https://github.com/nixallover)                             |
 
-| Chau Tran                                                            | Nicole Oliver                                                           | Rares Matei                                                           | Altan Stalker                                                           |
-| -------------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------- | ----------------------------------------------------------------------- |
-| ![Chau Tran](https://avatars.githubusercontent.com/u/25516557?s=160) | ![Nicole Oliver](https://avatars.githubusercontent.com/u/4440385?s=160) | ![Rares Matei](https://avatars.githubusercontent.com/u/5975076?s=160) | ![Altan Stalker](https://avatars.githubusercontent.com/u/6324206?s=160) |
-| [nartc](https://github.com/nartc)                                    | [nixallover](https://github.com/nixallover)                             | [rarmatei](https://github.com/rarmatei)                               | [StalkAltan](https://github.com/StalkAltan)                             |
-
-| Josh VanAllen                                                           | Austin Fahsl                                                           | Louie Weng                                                            |
-| ----------------------------------------------------------------------- | ---------------------------------------------------------------------- | --------------------------------------------------------------------- |
-| ![Josh VanAllen](https://avatars.githubusercontent.com/u/5290334?s=160) | ![Austin Fahsl](https://avatars.githubusercontent.com/u/6913035?s=160) | ![Louie Weng](https://avatars.githubusercontent.com/u/56288712?s=160) |
-| [joshvanallen](https://github.com/joshvanallen)                         | [fahslaj](https://github.com/fahslaj)                                  | [lourw](https://github.com/lourw)                                     |
+| Rares Matei                                                           | Altan Stalker                                                           | Josh VanAllen                                                           | Louie Weng                                                            |
+| --------------------------------------------------------------------- | ----------------------------------------------------------------------- | ----------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| ![Rares Matei](https://avatars.githubusercontent.com/u/5975076?s=160) | ![Altan Stalker](https://avatars.githubusercontent.com/u/6324206?s=160) | ![Josh VanAllen](https://avatars.githubusercontent.com/u/5290334?s=160) | ![Louie Weng](https://avatars.githubusercontent.com/u/56288712?s=160) |
+| [rarmatei](https://github.com/rarmatei)                               | [StalkAltan](https://github.com/StalkAltan)                             | [joshvanallen](https://github.com/joshvanallen)                         | [lourw](https://github.com/lourw)                                     |

SECURITY.md

@@ -13,3 +13,15 @@ Instead, please report them to the Security Team at security@nrwl.io.
 You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message.
 
 Nx follows the principle of Coordinated Vulnerability Disclosure.
+
+## What Should Be Reported
+
+The security email is for **demonstrable, verified vulnerabilities within the Nx codebase itself**.
+
+**Please do not use the security email for:**
+
+- Reports about outdated dependencies (e.g., "package X has a newer version available")
+- Reports about dependencies with known CVEs that do not directly affect Nx functionality
+- General vulnerability scanner output
+
+If you have a concern about an outdated dependency that you believe impacts Nx users, please open a [GitHub issue](https://github.com/nrwl/nx/issues/new/choose) instead.

astro-docs/.eslintignore

@@ -1,6 +0,0 @@
-node_modules/
-dist/
-.astro/
-.netlify/
-test-output/
-playwright-report/

astro-docs/.eslintrc.json

@@ -1,28 +0,0 @@
-{
-  "extends": ["plugin:playwright/recommended", "../.eslintrc.json"],
-  "ignorePatterns": ["!**/*"],
-  "overrides": [
-    {
-      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["**/*.spec.ts", "**/*.test.ts", "**/*.spec.js", "**/*.test.js"],
-      "rules": {
-        "playwright/no-standalone-expect": "off"
-      }
-    },
-    {
-      "files": ["*.ts", "*.tsx"],
-      "rules": {}
-    },
-    {
-      "files": ["*.js", "*.jsx"],
-      "rules": {}
-    },
-    {
-      "files": ["e2e/**/*.{ts,js,tsx,jsx}"],
-      "rules": {}
-    }
-  ]
-}

astro-docs/.vale.ini

@@ -0,0 +1,169 @@
+StylesPath = .vale/styles
+MinAlertLevel = suggestion
+
+# Treat Markdoc (.mdoc) files as markdown
+[formats]
+mdoc = md
+
+# Ignore Markdoc tag syntax and @-scoped package names to avoid false positives
+TokenIgnores = (\{%.*?%\}), (@\w+/[\w-]+)
+
+[src/content/docs/**/*.{mdoc,mdx,md}]
+BasedOnStyles = Nx
+
+# Disable heading check for config option reference pages (headings are camelCase property names)
+[src/content/docs/technologies/angular/angular-rsbuild/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/angular/angular-rspack/create-config.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/build-tools/webpack/Guides/webpack-plugins.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Deprecated/affected-graph.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Deprecated/print-affected.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/react/next/Guides/next-config-setup.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for release notes (timestamps as headings)
+[src/content/docs/reference/Nx Cloud/release-notes.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for nx-cloud-cli (CLI flags as headings)
+[src/content/docs/reference/nx-cloud-cli.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for nx-console-settings (config option headings)
+[src/content/docs/reference/nx-console-settings.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for pages with camelCase API property headings
+[src/content/docs/reference/nx-json.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/project-configuration.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Deprecated/legacy-cache.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/extending-nx/local-executors.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/guides/Nx Release/programmatic-api.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/node/Guides/wait-for-tasks.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/test-tools/vitest/Guides/testing-without-building-dependencies.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/angular/Guides/nx-and-angular.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for merge-atomized-outputs (warning message as heading)
+[src/content/docs/technologies/test-tools/playwright/Guides/merge-atomized-outputs.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for plugin introduction pages (@nx/ package name headings)
+[src/content/docs/technologies/build-tools/docker/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/build-tools/rspack/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/build-tools/webpack/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/dotnet/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/eslint/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/java/gradle/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/java/maven/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/react/expo/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/react/react-native/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/test-tools/cypress/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/test-tools/detox/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/test-tools/playwright/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/test-tools/storybook/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/vue/nuxt/introduction.mdoc]
+Nx.Headings = NO
+
+# Disable heading check for remaining pages with structural false positives
+# (code identifiers, slashes, quotes, parenthetical words in headings)
+[src/content/docs/extending-nx/create-install-package.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/extending-nx/create-preset.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/getting-started/editor-setup.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/guides/Adopting Nx/from-turborepo.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/guides/Tasks & Caching/reduce-repetitive-configuration.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/guides/Tasks & Caching/workspace-watching.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Deprecated/custom-tasks-runner.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Deprecated/rescope.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/Nx Cloud/credits-pricing.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/reference/nx-mcp.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/eslint/Guides/custom-workspace-rules.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/module-federation/Guides/nx-module-federation-plugin.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/module-federation/introduction.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/technologies/react/Guides/react-router.mdoc]
+Nx.Headings = NO
+
+[src/content/docs/troubleshooting/unknown-local-cache.mdoc]
+Nx.Headings = NO
+
+# Verbatim legal text - skip Nx voice rules
+[src/content/docs/reference/powerpack-license.mdoc]
+BasedOnStyles =
+Nx.Headings = NO
+Nx.ProductPossessives = NO
+Nx.SerialComma = NO

astro-docs/.vale/styles/Nx/BannedPhrases.yml

@@ -0,0 +1,41 @@
+extends: existence
+message: "Avoid AI-sounding phrase '%s'. Rewrite to be direct."
+level: error
+ignorecase: true
+tokens:
+  - "It's important to note that"
+  - "It's worth noting that"
+  - 'It should be noted that'
+  - 'In this section, we will explore'
+  - "Let's dive into"
+  - "Let's take a closer look at"
+  - "Whether you're a beginner or an experienced developer"
+  - "In today's fast-paced development environment"
+  - 'Unlock the power of'
+  - 'Harness the power of'
+  - 'Take your workspace to the next level'
+  - 'Streamline your workflow'
+  - 'This comprehensive guide will'
+  - 'Without further ado'
+  - 'In conclusion'
+  - 'To summarize'
+  - "As we've seen"
+  - 'Needless to say'
+  - 'As a matter of fact'
+  - 'Generally speaking'
+  - 'It is worth mentioning'
+  - 'Game-changer'
+  - 'Cutting-edge'
+  - 'Groundbreaking'
+  - 'delve into'
+  - 'delving into'
+  - 'embark on a journey'
+  - 'embark on'
+  - 'navigate the realm of'
+  - 'in the realm of'
+  - 'in the world of'
+  - 'rich tapestry'
+  - 'tapestry of'
+  - 'at its core'
+  - 'a testament to'
+  - 'plays a (vital|crucial|pivotal|key) role'

astro-docs/.vale/styles/Nx/Closers.yml

@@ -0,0 +1,13 @@
+extends: existence
+message: "Possible restatement closer '%s'. Check whether this sentence adds new info or just summarizes."
+level: warning
+ignorecase: true
+tokens:
+  - 'This is (why|how|what|the reason)'
+  - 'In short'
+  - 'In summary'
+  - 'Ultimately'
+  - 'All in all'
+  - 'At the end of the day'
+  - 'The (key|main) takeaway'
+  - 'This (is|was) the gap'

astro-docs/.vale/styles/Nx/Headings.yml

@@ -0,0 +1,138 @@
+extends: capitalization
+message: "Use sentence case for headings. '%s' should be '%s'."
+level: error
+scope: heading
+match: $sentence
+indicators:
+  - ':'
+exceptions:
+  - Nx
+  - Nx Cloud
+  - Nx Console
+  - Nx Agents
+  - Nx Replay
+  - AI
+  - CI
+  - CD
+  - API
+  - APIs
+  - URL
+  - URLs
+  - CLI
+  - PR
+  - PRs
+  - IDE
+  - TypeScript
+  - JavaScript
+  - Angular
+  - React
+  - Vue
+  - Nuxt
+  - Vite
+  - Webpack
+  - Rspack
+  - Rollup
+  - ESLint
+  - Prettier
+  - GitHub
+  - GitHub Actions
+  - GitLab
+  - BitBucket
+  - BitBucket Cloud
+  - Azure DevOps
+  - Azure
+  - Docker
+  - Dockerfile
+  - Kubernetes
+  - Gradle
+  - Maven
+  - Node.js
+  - Deno
+  - Bun
+  - pnpm
+  - npm
+  - Yarn
+  - Next.js
+  - Remix
+  - Astro
+  - Storybook
+  - Jest
+  - Vitest
+  - Cypress
+  - Playwright
+  - Express
+  - Fastify
+  - Nest.js
+  - NestJS
+  - Expo
+  - React Native
+  - Module Federation
+  - TanStack
+  - TanStack Router
+  - IntelliJ
+  - VS Code
+  - VSCode
+  - WebStorm
+  - Turborepo
+  - Lerna
+  - Bazel
+  - JSON
+  - YAML
+  - TOML
+  - CSS
+  - HTML
+  - SSR
+  - SSG
+  - MFE
+  - DTE
+  - SWC
+  - Rsbuild
+  - Rolldown
+  # Abbreviations and acronyms
+  - AI
+  - UI
+  - DX
+  - ID
+  - FAQ
+  - SAML
+  - DPE
+  - WSL
+  - EJS
+  - AST
+  - TTG
+  - PATs
+  - IDEs
+  - MCP
+  - HTTP
+  - HTTPS
+  - INI
+  - VCS
+  - LTS
+  - DTS
+  - SVG
+  - SVGs
+  - SVGR
+  - EAS
+  - iOS
+  - AWS
+  - S3
+  - E2E
+  - TL;DR
+  - NuGet
+  - MongoDB
+  - OpenShift
+  - Vercel
+  - Netlify
+  # Proper nouns
+  - RxJS
+  - JetBrains
+  - Neovim
+  - PnP
+  - Self-Healing
+  - AMD64
+  - ARM64
+  # Filenames and env vars
+  - SELF_HEALING.md
+  - CLAUDE.md
+  - NODE_AUTH_TOKEN
+  - NX_REJECT_UNKNOWN_LOCAL_CACHE

astro-docs/.vale/styles/Nx/MarketingLanguage.yml

@@ -0,0 +1,32 @@
+extends: existence
+message: "Avoid marketing language '%s'. Be specific about what the feature does instead."
+level: suggestion
+ignorecase: true
+tokens:
+  - 'effortless'
+  - 'effortlessly'
+  - 'seamless'
+  - 'seamlessly'
+  - 'powerful'
+  - 'robust'
+  - 'comprehensive'
+  - 'leverage'
+  - 'utilize'
+  - 'facilitate'
+  - 'aforementioned'
+  - 'best-in-class'
+  - 'world-class'
+  - 'next-level'
+  - 'supercharge'
+  - 'delve'
+  - 'underscore'
+  - 'underscores'
+  - 'foster'
+  - 'empower'
+  - 'meticulous'
+  - 'meticulously'
+  - 'crucial'
+  - 'pivotal'
+  - 'paramount'
+  - 'intricate'
+  - 'multifaceted'

astro-docs/.vale/styles/Nx/PassiveVoice.yml

@@ -0,0 +1,25 @@
+extends: existence
+message: "Prefer active voice. '%s' could be rewritten."
+level: suggestion
+ignorecase: true
+tokens:
+  - 'is cached by'
+  - 'is built by'
+  - 'is run by'
+  - 'is executed by'
+  - 'is generated by'
+  - 'is created by'
+  - 'is managed by'
+  - 'is handled by'
+  - 'is provided by'
+  - 'is configured by'
+  - 'is determined by'
+  - 'is computed by'
+  - 'is resolved by'
+  - 'is stored by'
+  - 'are cached by'
+  - 'are built by'
+  - 'are run by'
+  - 'are executed by'
+  - 'are generated by'
+  - 'are created by'

astro-docs/.vale/styles/Nx/ProductCapitalization.yml

@@ -0,0 +1,9 @@
+extends: substitution
+message: "Use '%s' instead of '%s'. Product names must be capitalized."
+level: error
+ignorecase: false
+swap:
+  '(?:nx cloud|NX Cloud|Nx cloud|NX cloud)': Nx Cloud
+  '(?:nx console|NX Console|Nx console|NX console)': Nx Console
+  '(?:nx agents|NX Agents|Nx agents|NX agents)': Nx Agents
+  '(?:nx replay|NX Replay|Nx replay|NX replay)': Nx Replay

astro-docs/.vale/styles/Nx/ProductPossessives.yml

@@ -0,0 +1,6 @@
+extends: existence
+message: "Don't use possessives on product names. Use 'the Nx configuration' instead of 'Nx's configuration'."
+level: error
+ignorecase: false
+tokens:
+  - "Nx's"

astro-docs/.vale/styles/Nx/SelfReferential.yml

@@ -0,0 +1,26 @@
+extends: existence
+message: "Don't write about the document itself. Get right to the content. Remove '%s'."
+level: error
+ignorecase: true
+tokens:
+  - 'This page explains'
+  - 'This page describes'
+  - 'This page covers'
+  - 'This page shows'
+  - 'This document covers'
+  - 'This document explains'
+  - 'This document describes'
+  - 'In this guide'
+  - 'In this tutorial'
+  - 'In this section'
+  - 'This guide will'
+  - 'This tutorial will'
+  - 'This section will'
+  - "we'll walk through"
+  - 'we will walk through'
+  - "we'll explore"
+  - 'we will explore'
+  - "we'll cover"
+  - 'we will cover'
+  - "we'll look at"
+  - 'we will look at'

astro-docs/.vale/styles/Nx/SentencePatterns.yml

@@ -0,0 +1,14 @@
+extends: existence
+message: "Rewrite to lead with the reader's action instead of '%s'. For example, 'You can ...' or 'Run ...'."
+level: warning
+ignorecase: true
+tokens:
+  - 'This allows you to'
+  - 'This enables you to'
+  - 'This lets you'
+  - 'This provides you with'
+  - 'This gives you the ability to'
+  - 'Nx allows you to'
+  - 'Nx enables you to'
+  - 'Nx provides the ability to'
+  - 'Nx provides you with'

astro-docs/.vale/styles/Nx/SerialComma.yml

@@ -0,0 +1,7 @@
+extends: existence
+message: "Use the Oxford (serial) comma before 'and' or 'or' in a list of three or more items."
+level: suggestion
+scope: sentence
+tokens:
+  - '\w+,\s\w+\sand\s'
+  - '\w+,\s\w+\sor\s'

astro-docs/.vale/styles/Nx/Terminology.yml

@@ -0,0 +1,9 @@
+extends: substitution
+message: "Use '%s' instead of '%s'."
+level: warning
+ignorecase: true
+swap:
+  schematic: generator
+  schematics: generators
+  memoized: cached
+  stored results: cached

astro-docs/.vale/styles/Nx/TrustWords.yml

@@ -0,0 +1,11 @@
+extends: existence
+message: "Avoid '%s'. If something were truly simple, you wouldn't need to document it."
+level: suggestion
+ignorecase: true
+tokens:
+  - 'easily'
+  - 'simply'
+  - 'straightforward'
+  - 'obviously'
+  - 'of course'
+  - 'trivial'

astro-docs/README.md

@@ -22,6 +22,48 @@ This documentation site leverages Astro's static site generation capabilities wi
 - Dynamic API documentation generation from Nx packages and CLI commands
 - Community plugin registry
 
+## Information Architecture Principles
+
+When creating or reorganizing documentation, follow these 5 principles to determine where content belongs.
+
+### 1. Progressive Disclosure (The "Journey" Rule)
+
+- **Concept:** Don't overwhelm the user. Reveal complexity only as they advance in their journey.
+- **The Test:** _Is this for the First 30 Minutes (Getting Started), the First 30 Days (Features), or Forever (Reference)?_
+
+### 2. Category Homogeneity (The "Scan" Rule)
+
+- **Concept:** Items in a list must be of the same "type" (noun, verb, or concept) to reduce cognitive load.
+- **The Test:** _Does this list mix Concepts (Mental Model), Tasks (Update Nx), and Products (React)? If yes, split it._
+
+### 3. Type-Based Navigation (The "Intent" Rule)
+
+- **Concept:** Separate **Learning** (Narrative/Guides) from **Looking Up** (Reference/API).
+- **The Test:** _Is the user here to learn a workflow (Guide) or look up a flag syntax (Reference)?_
+
+### 4. The Pen & Paper Test (The "Theory" Rule)
+
+- **Concept:** Distinguish Architecture from Features to keep "Core Concepts" pure.
+- **The Test:** _Can I explain this using only a pen and paper?_
+- **Yes:** It goes in **How Nx Works** (Architecture).
+- **No (I need a terminal):** It goes in **Platform Features** (Feature).
+
+### 5. Universal vs. Specific (The "Placement" Rule)
+
+- **Concept:** Distinguish Platform features from Ecosystem tools to prevent "Features" from becoming a junk drawer.
+- **The Test:** _Does this feature apply to EVERY user (e.g., Caching, Agents)?_
+- **Yes:** **Platform Features**.
+- **No (Only React users):** **Technologies**.
+
+### Sidebar Structure
+
+The sidebar has 4 top-level sections that follow the user journey:
+
+1. **Getting Started** - Essential setup, tutorials, and core concepts (How Nx Works, Platform Features)
+2. **Technologies** - Framework and tool-specific guides (React, Angular, Node, build tools, test tools)
+3. **Knowledge Base** - Recipes, troubleshooting, and topic-specific guides
+4. **Reference** - Exhaustive facts, no narrative (CLI commands, configuration, API docs)
+
 ## Project Structure
 
 ```
@@ -280,3 +322,47 @@ The Framer page should render JSON inside a `<pre>` tag:
 - Users can dismiss the banner (stored in localStorage)
 - If `enabled` is `false` or `activeUntil` has passed, the banner won't show
 - If `BANNER_URL` is not set, an empty collection is generated
+
+## Versioned Docs
+
+When a new major Nx version is released (or about to be released), create a versioned snapshot of the docs site so the previous version remains accessible at `{major}.nx.dev` (e.g. `22.nx.dev`).
+
+### Creating a Version Snapshot
+
+```bash
+node ./scripts/create-versioned-docs.mts 22
+```
+
+This will:
+
+1. Fetch tags from origin, find the latest stable release for that major (e.g. `22.6.4`)
+2. Checkout that tag, install deps, and build the docs site
+3. Create an orphan git branch `22` containing only the pre-built static site plus minimal scaffolding (root `package.json`, `nx.json`, `pnpm-lock.yaml`, `netlify.toml`, and a no-op `nx-dev` project) so Netlify's configured build command succeeds instantly
+4. Return to your original branch
+
+If no stable tags exist for that major version, it builds from the current branch.
+
+For Nx 21+, the script builds `astro-docs` (Astro/Starlight). For legacy Nx 18–20, it builds `nx-dev` (Next.js with static export) — this path will be removed once those versions are no longer maintained.
+
+#### Flags
+
+- `--force` — overwrite an existing local/remote `{major}` branch
+- `--redirect-to-prod` — skip the build and produce a branch that 301s every path to `https://nx.dev/docs`. Used to retire an old versioned subdomain (e.g. `16.nx.dev`) without maintaining its docs
+
+```bash
+# Retire an old versioned site
+node ./scripts/create-versioned-docs.mts 16 --redirect-to-prod
+```
+
+### Pushing the Branch
+
+```bash
+git push -f origin 22
+```
+
+### Deployment Setup
+
+Versioned sites are served via Netlify branch deploys of the main `nx-dev` Netlify site, with custom domains managed in Squarespace.
+
+- **Netlify** — each `{major}` branch is deployed as a [branch deploy](https://docs.netlify.com/site-deploys/overview/#branch-deploy-controls) of the `nx-dev` site. The branch's root `netlify.toml` overrides the UI build settings so Netlify serves the pre-built static files (no rebuild, no `@netlify/plugin-nextjs`). Add the branch to the site's branch deploy allowlist, then add `{major}.nx.dev` as a domain alias pointing at the branch deploy
+- **Squarespace** — DNS for `nx.dev` is managed in Squarespace. Add a CNAME for `{major}` pointing at the Netlify branch deploy hostname

astro-docs/STYLE_GUIDE.md

@@ -0,0 +1,472 @@
+# Nx Documentation Style Guide
+
+These rules apply to all content under `astro-docs/src/content/docs/`.
+[Vale](#vale-configuration) enforces the mechanical ones automatically.
+
+## Information architecture
+
+When creating or reorganizing documentation, follow these five principles to determine where content belongs.
+
+### 1. Progressive disclosure (the "journey" rule)
+
+Don't overwhelm the user. Reveal complexity only as they advance in their journey.
+
+**The test:** Is this for the first 30 minutes (Getting Started), the first 30 days (Features), or forever (Reference)?
+
+### 2. Category homogeneity (the "scan" rule)
+
+Items in a list must be of the same "type" (noun, verb, or concept) to reduce cognitive load.
+
+**The test:** Does this list mix concepts (mental model), tasks (update Nx), and products (React)? If yes, split it.
+
+### 3. Type-based navigation (the "intent" rule)
+
+Separate learning (narrative/guides) from looking up (reference/API).
+
+**The test:** Is the user here to learn a workflow (guide) or look up a flag syntax (reference)?
+
+### 4. The pen and paper test (the "theory" rule)
+
+Distinguish architecture from features to keep "core concepts" pure.
+
+**The test:** Can I explain this using only a pen and paper?
+
+- Yes: It goes in **How Nx Works** (architecture).
+- No (I need a terminal): It goes in **Platform Features** (feature).
+
+### 5. Universal vs. specific (the "placement" rule)
+
+Distinguish platform features from ecosystem tools to prevent "Features" from becoming a junk drawer.
+
+**The test:** Does this feature apply to every user (e.g., caching, Nx Agents)?
+
+- Yes: **Platform Features**.
+- No (only React users): **Technologies**.
+
+### Sidebar structure
+
+The sidebar has four top-level sections that follow the user journey:
+
+1. **Getting Started** - Essential setup, tutorials, and core concepts (How Nx Works, Platform Features)
+2. **Technologies** - Framework and tool-specific guides (React, Angular, Node, build tools, test tools)
+3. **Knowledge Base** - Recipes, troubleshooting, and topic-specific guides
+4. **Reference** - Exhaustive facts, no narrative (CLI commands, configuration, API docs)
+
+## Structural anti-AI rules (longform)
+
+Sentence-level edits don't fix AI voice in longform pieces. The structural tells matter more.
+
+### One canonical home per point
+
+Each substantive point lives in exactly one section. Other sections link or reference it in one phrase. They don't re-explain.
+
+### No drama-beat echoes
+
+A short sentence (under ~10 words) immediately after a long one, restating the long one for emphasis, is an AI tic.
+Cover the short sentence with your thumb. If nothing is lost, cut it.
+
+### No restatement closers
+
+Read the last sentence of each paragraph alone.
+If it summarizes what the paragraph said rather than adding a fact, judgment, or turn, cut it.
+
+### Match claims to evidence
+
+Every quantifier ("always", "never", "all", "completely", "fully", "rarely") and every counterfactual ("would have prevented", "would have caught") should be checked against the evidence actually in the doc.
+
+Two failure modes:
+
+- **Over-generalization**: one observed instance written as a broad pattern. If the doc has one data point, don't write "users frequently" or "this always happens."
+- **Under-calibration**: softening a true absolute, or absolutizing a partial fix. "Would have prevented" is fine when the fix categorically closes the outcome. It's wrong when the fix closes one path of several.
+
+Ask of each strong claim: "what in this doc supports the strength of this word?" If nothing, weaken or cite.
+
+### Pre-publish pass order
+
+Run passes in this order. Structural first, vocabulary last.
+
+1. Canonical-home audit: where does each substantive point live?
+2. Repetition count: grep your two or three core findings. If a finding appears more than twice in prose, the third is probably redundant.
+3. Drama-beat sweep.
+4. Closer pass.
+5. Claim audit: for each absolute and each counterfactual, check what evidence in the doc supports that strength. Weaken or cite.
+6. End-to-end consistency read.
+7. Vocabulary grep (cheapest, lowest value).
+
+## The Nx voice
+
+Nx documentation is **direct, practical, and confident**. We write like a knowledgeable colleague pairing with you, not like a textbook, not like a marketing page, and not like a chatbot.
+
+The voice should be:
+
+- **Conversational but efficient.** Use contractions. Get to the point. Don't pad sentences.
+- **Second person.** Write "you". Address the reader directly.
+- **Action-oriented.** Lead with what the reader can _do_, not what Nx _is_.
+- **Honest about tradeoffs.** Don't oversell. If something has limitations, say so.
+
+### Voice do's and don'ts
+
+| Do                                                                       | Don't                                                                                               |
+| ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------- |
+| "You can speed up builds by enabling remote caching."                    | "Nx allows you to speed up builds."                                                                 |
+| "Run `nx build` to build your project."                                  | "In order to build your project, you can run the `nx build` command."                               |
+| "This works best with fewer than 50 projects."                           | "This feature can easily scale to any number of projects."                                          |
+| "Nx reads your `vite.config.ts` and infers build targets automatically." | "Nx provides a robust and comprehensive mechanism for inferring build targets."                     |
+| "If the cache is stale, delete `.nx/cache` and retry."                   | "Should you encounter issues with caching, you may want to consider clearing your cache directory." |
+
+### Anti-AI language
+
+Edit AI-assisted drafts so they don't read like AI wrote them. Phrase-level passes alone won't do it. Apply the structural rules above first.
+
+**Never use these phrases:**
+
+- "It's important to note that..."
+- "It's worth noting that..." / "It should be noted that..."
+- "In this section, we will explore..."
+- "Let's dive into..." / "Let's take a closer look at..."
+- "Delve into..." / "Delving into..."
+- "Embark on a journey..." / "Embark on..."
+- "Navigate the realm of..." / "In the realm of..." / "In the world of..."
+- "At its core..."
+- "A testament to..."
+- "Rich tapestry" / "Tapestry of..."
+- "Plays a vital/crucial/pivotal/key role"
+- "Whether you're a beginner or an experienced developer..."
+- "In today's fast-paced development environment..."
+- "Unlock the power of..." / "Harness the power of..."
+- "Take your workspace to the next level"
+- "Streamline your workflow" (as a generic claim without specifics)
+- "This comprehensive guide will..."
+- "Without further ado..."
+- "In conclusion..." / "To summarize..." / "As we've seen..."
+- "Game-changer" / "Cutting-edge" / "Groundbreaking"
+- "Seamless" / "Seamlessly" (unless describing an actual integration)
+
+**Avoid hedging words:**
+
+- "Essentially" / "Basically" / "Effectively"
+- "Generally speaking"
+- "It is worth mentioning"
+- "Arguably"
+- "Needless to say"
+- "As a matter of fact"
+
+**Watch for AI-style sentence patterns:**
+
+- Sentences that start with "This allows you to..." or "This enables you to...". Rewrite to lead with the reader's action.
+- Paragraphs that start with a general claim and then restate it slightly differently. Say it once.
+- Excessive use of "robust", "leverage", "utilize", "facilitate", "comprehensive", "aforementioned."
+- TED-talk verbs: "delve", "underscore" (as verb), "foster", "empower", "embark", "unlock", "harness". Replace with the concrete action.
+- Filler adjectives: "meticulous", "crucial", "pivotal", "paramount", "intricate", "multifaceted".
+- Lists where every item starts with the same grammatical structure repeated 5+ times with slight variation. Vary your phrasing.
+
+### Self-referential writing
+
+Don't write about the document itself.
+
+Do:
+
+- "Nx uses a project graph to determine task dependencies."
+
+Don't:
+
+- "This page explains how Nx uses a project graph."
+- "In this guide, we'll walk through..."
+- "This document covers..."
+
+Get right to the point. The reader already knows they're on a page.
+
+### Building trust
+
+Don't use filler words that undermine the reader's trust.
+
+- Don't use "easily", "simply", "just", or "straightforward". If something were truly simple, you wouldn't need to document it. These words also make readers feel bad when they struggle.
+- Don't use marketing language: "This feature will save you hours" or "Nx makes CI effortless."
+- Be specific instead: "Remote caching can reduce CI times from 45 minutes to under 5 minutes for cache-hit builds."
+
+### Customer perspective
+
+Focus on what the reader can do, not what Nx does.
+
+Do:
+
+- "Use `nx affected` to run tasks only for projects impacted by your changes."
+
+Don't:
+
+- "Nx allows you to run affected tasks."
+- "Nx provides the ability to run tasks selectively."
+
+Words like "allow" and "enable" are signals you're writing from the product's perspective instead of the reader's.
+
+## Language
+
+Write in US English.
+
+### Active voice
+
+Use active voice in most cases.
+
+Do: "Nx caches the build output."
+Don't: "The build output is cached by Nx."
+
+Exception: When "Nx" as the subject sounds awkward, passive voice is fine. "The output is stored in `.nx/cache`" is better than "Nx stores the output in `.nx/cache`" if Nx isn't the focus of the sentence.
+
+### Contractions
+
+Use contractions. They make the text feel natural.
+
+- "You'll need to configure..." not "You will need to configure..."
+- "It doesn't support..." not "It does not support..."
+
+Don't contract for emphasis in warnings or error descriptions:
+
+- "**Do not** delete the `nx.json` file."
+- "Requests to localhost **are not** allowed."
+
+Don't contract proper nouns: "the Vite plugin is..." not "Vite's a plugin..."
+
+### Capitalization
+
+Use sentence case for headings. Capitalize proper nouns only.
+
+- `# Use remote caching to speed up CI`
+- `## Configure the Vite plugin`
+
+Feature names are lowercase unless they are a proper product name:
+
+| Correct        | Incorrect      |
+| -------------- | -------------- |
+| remote caching | Remote Caching |
+| project graph  | Project Graph  |
+| Nx Cloud       | nx cloud       |
+| Nx Console     | nx console     |
+| Nx Agents      | nx agents      |
+| Nx Replay      | nx replay      |
+
+### Acronyms
+
+Spell out acronyms on first use per page. Don't spell out widely-known ones: CI, CD, API, URL, CLI, PR, IDE.
+
+Don't make acronyms plural with apostrophes. Use `APIs`, not `API's`.
+
+### Numbers
+
+Spell out zero through nine. Use numerals for 10 and above. Always use numerals with units: "5 minutes", "3 projects."
+
+### Possessives
+
+Don't use possessives on product names. "the Docker CLI", not "Docker's CLI." "the Nx configuration", not "Nx's configuration."
+
+## Text
+
+### Headings
+
+- Don't skip heading levels (e.g., `##` to `####`).
+- Don't use code in headings unless it's essential (like a CLI command).
+- Don't use bold text in headings.
+- Keep headings short and scannable. Lead with keywords.
+
+### Line length
+
+- Wrap lines at approximately 100 characters for readability in diffs.
+- Start each new sentence on a new line.
+- Exception: Don't break links across lines.
+
+### Punctuation
+
+- Use serial (Oxford) commas: "React, Angular, and Vue."
+- Use one space between sentences.
+- Don't use semicolons. Use two sentences instead.
+- Don't use em dashes or en dashes. Use commas or separate sentences.
+
+### Placeholder text
+
+Use `<` and `>` for values the reader must replace:
+
+```shell
+nx run <project-name>:build
+```
+
+If the placeholder is inline, wrap it in a single backtick: `<your-project>`.
+
+### Bold
+
+Use bold for:
+
+- UI elements: "Select **Add Connection**."
+- Navigation paths: "Go to **Settings** > **Workspace**."
+
+Don't use bold for emphasis or keywords. If you need emphasis, rewrite the sentence to be clearer.
+
+### Inline code
+
+Use inline code (single backticks) for:
+
+- Commands and CLI arguments: `nx build`, `--parallel`
+- File names and paths: `nx.json`, `.nx/cache`
+- Configuration keys: `targetDefaults`, `namedInputs`
+- Short outputs and values: `true`, `false`, `success`
+
+### Code blocks
+
+Use triple backticks with a language identifier:
+
+````markdown
+```json
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true
+    }
+  }
+}
+```
+````
+
+- Always specify a syntax language. Use `plaintext` if nothing else fits.
+- Add a blank line before and after code blocks.
+- For long config files, show only the relevant section and use comments to indicate omitted parts:
+
+```json
+{
+  // ... other config
+  "targetDefaults": {
+    "build": {
+      "cache": true
+    }
+  }
+}
+```
+
+## Links
+
+Links help readers find related information, but too many links make text hard to read.
+
+### General rules
+
+- Don't duplicate links. If you link to a page once, don't link to it again on the same page.
+- Don't use links in headings.
+- Avoid more than 15 links to other pages on any single page.
+- Avoid multiple links in a single paragraph when possible.
+
+### Link text
+
+Use descriptive text, not "here" or "this page."
+
+Do:
+
+- "For more information, see [remote caching](/features/cache)."
+- "To configure task pipelines, see [task pipeline configuration](/concepts/task-pipeline-configuration)."
+
+Don't:
+
+- "For more information, see [this page](/features/cache)."
+- "Click [here](/features/cache) to learn more."
+- "For more information, see the [Remote Caching](/features/cache) documentation."
+
+Standard patterns:
+
+- `For more information, see [link text](url).`
+- `To <do this thing>, see [link text](url).`
+
+### External links
+
+Minimize external links. They break over time and are hard to maintain. When you must link externally, prefer official documentation (e.g., Vite docs, Webpack docs) over blog posts or third-party guides.
+
+## Lists
+
+- Use ordered lists for sequences of steps.
+- Use unordered lists when order doesn't matter.
+- Use dashes (`-`) for unordered lists.
+- Start ordered list items with `1.` (Markdown auto-increments).
+- Make list items parallel in structure.
+- Add a colon after the introductory phrase.
+- Don't use list items to complete an introductory sentence.
+
+Do:
+
+```markdown
+You can clear the cache in the following ways:
+
+- Delete the `.nx/cache` directory manually.
+- Run `nx reset` to clear all cached results.
+```
+
+Don't:
+
+```markdown
+You can clear the cache by:
+
+- Deleting the `.nx/cache` directory manually.
+- Running `nx reset`.
+```
+
+## Tables
+
+Use tables for structured data that benefits from a matrix layout. For simple lists of items with descriptions, use a regular list instead.
+
+- Don't leave cells empty. Use "N/A" or "None."
+- Use sentence case for headers.
+- Keep the header and delimiter rows the same length.
+
+## Nx-specific terminology
+
+Use these terms consistently. When writing about Nx concepts, use the exact term from this list.
+
+| Term           | Usage notes                                                                                |
+| -------------- | ------------------------------------------------------------------------------------------ |
+| workspace      | The root directory managed by Nx. Not "repo" or "monorepo" when referring to Nx's context. |
+| project        | An app or library within the workspace.                                                    |
+| target         | A task that can be run for a project (e.g., `build`, `test`, `lint`).                      |
+| executor       | The implementation behind a target. Not "builder."                                         |
+| generator      | Code scaffolding tool. Not "schematic."                                                    |
+| plugin         | An Nx plugin that provides executors, generators, or graph inference.                      |
+| task           | A specific invocation of a target for a project (e.g., `myapp:build`).                     |
+| project graph  | The dependency graph between projects.                                                     |
+| affected       | Projects impacted by a code change.                                                        |
+| cache / cached | Not "memoized" or "stored results."                                                        |
+| remote caching | Sharing cached results across machines. Specific product: "Nx Replay."                     |
+| Nx Cloud       | The hosted CI/CD product. Always capitalized.                                              |
+| Nx Console     | The IDE extension. Always capitalized.                                                     |
+| Nx Agents      | Distributed task execution product. Always capitalized.                                    |
+| Nx Replay      | Remote caching product. Always capitalized.                                                |
+| `nx.json`      | Always in code style.                                                                      |
+| `project.json` | Always in code style.                                                                      |
+
+## Vale configuration
+
+[Vale](https://vale.sh) enforces the mechanical rules automatically. Configuration lives in `astro-docs/`:
+
+- `.vale.ini`: main config. Scopes rules to `src/content/docs/**/*.{mdoc,mdx,md}`.
+- `.vale/styles/Nx/`: custom rules for Nx documentation.
+
+### Running Vale
+
+```shell
+# Via Nx target (recommended)
+nx vale astro-docs
+
+# Directly (from astro-docs/ directory)
+vale src/content/docs/
+```
+
+### Installing Vale
+
+Vale is managed via [mise](https://mise.jdx.dev/). Run `mise install` from the repo root to install it.
+You can also install directly via `brew install vale` (macOS) or `apt-get install vale` (Linux).
+
+### Rule tiers
+
+| Tier           | Severity     | Rules                                                                                                            |
+| -------------- | ------------ | ---------------------------------------------------------------------------------------------------------------- |
+| 1 - Mechanical | `error`      | Banned phrases, product capitalization                                                                           |
+| 2 - Structural | `warning`    | Heading case, terminology, product possessives, self-referential writing, sentence patterns, restatement closers |
+| 3 - Voice      | `suggestion` | Trust-undermining words, marketing language, passive voice, serial commas                                        |
+
+### Adding new rules
+
+Create a new `.yml` file in `.vale/styles/Nx/`.
+Vale supports several [extension points](https://vale.sh/docs/styles): `existence`, `substitution`, `occurrence`, `repetition`, `consistency`, `conditional`, `capitalization`, and `metric`.
+
+Set `level` to match the tier: `error` for mechanical rules, `warning` for structural, `suggestion` for voice/judgment.

astro-docs/astro.config.mjs

@@ -5,15 +5,19 @@ import netlify from '@astrojs/netlify';
 import react from '@astrojs/react';
 import markdoc from '@astrojs/markdoc';
 import tailwindcss from '@tailwindcss/vite';
+import sitemap from '@astrojs/sitemap';
 import { sidebar } from './sidebar.mts';
+import rehypeTableOptionLinks from './src/plugins/utils/rehype-table-option-links.ts';
+import { resolveNxDevUrl } from './src/utils/resolve-nx-dev-url.ts';
+
+// Always resolve NX_DEV_URL so downstream consumers (Footer, Header) pick it up.
+// For deploy previews this overrides any site-level env var to point to the matching preview.
+process.env.NX_DEV_URL = resolveNxDevUrl();
 
 const BASE = '/docs';
 
 // This is exposed as window.__CONFIG
 const PUBLIC_CONFIG = {
-  cookiebotDisabled: process.env.COOKIEBOT_DISABLED === 'true',
-  cookiebotId: process.env.COOKIEBOT_ID ?? null,
-  gaMeasurementId: 'UA-88380372-10',
   gtmMeasurementId: 'GTM-KW8423B6',
   isProd: process.env.NODE_ENV === 'production',
 };
@@ -33,7 +37,36 @@ export default defineConfig({
       },
     },
   },
+  markdown: {
+    rehypePlugins: [rehypeTableOptionLinks],
+  },
   trailingSlash: 'never',
+  redirects: {
+    '/knowledge-base/installation':
+      '/docs/knowledge-base/installation-and-updates',
+    '/guides/nx-cloud/ci-resource-usage':
+      '/docs/features/ci-features/resource-usage',
+    '/reference/remote-cache-plugins':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/s3-cache':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/s3-cache/overview':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/gcs-cache':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/gcs-cache/overview':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/azure-cache':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/azure-cache/overview':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/shared-fs-cache':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/shared-fs-cache/overview':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+    '/reference/remote-cache-plugins/shared-fs-cache/generators':
+      '/docs/reference/deprecated/self-hosted-cache-packages',
+  },
   // This adapter doesn't support local previews, so only load it on Netlify.
   adapter: process.env['NETLIFY'] ? netlify() : undefined,
   integrations: [
@@ -51,27 +84,12 @@ export default defineConfig({
         replacesTitle: true,
       },
       disable404Route: true,
+      lastUpdated: true,
       head: [
         {
           tag: 'script',
           content: `window.__CONFIG = ${JSON.stringify(PUBLIC_CONFIG)};`,
         },
-        ...(process.env.COOKIEBOT_ID &&
-        process.env.COOKIEBOT_DISABLED !== 'true'
-          ? [
-              {
-                /** @type {"script"} */
-                tag: 'script',
-                attrs: {
-                  id: 'Cookiebot',
-                  src: 'https://consent.cookiebot.com/uc.js',
-                  'data-cbid': process.env.COOKIEBOT_ID,
-                  'data-blockingmode': 'auto',
-                  type: 'text/javascript',
-                },
-              },
-            ]
-          : []),
         {
           tag: 'script',
           attrs: {
@@ -87,17 +105,14 @@ export default defineConfig({
         // since the sidebar doesn't auto generate w/ dynamic routes from src/pages/reference
         // only the src/content/docs/reference files
         './src/plugins/sidebar-reference-updater.middleware.ts',
-        './src/plugins/sidebar-icons.middleware.ts',
         './src/plugins/og.middleware.ts',
         './src/plugins/github-stars.middleware.ts',
         './src/plugins/raw-content.middleware.ts',
         './src/plugins/canonical.middleware.ts',
+        './src/plugins/schema.middleware.ts',
       ],
       markdown: {
-        // this breaks the renderMarkdown function in the plugin loader due to starlight path normalization
-        // as to _why_ it has to normalize a path?
-        // idk just working around the issue for now but we'll want to have linked headers so will need to fix
-        headingLinks: false,
+        headingLinks: true,
       },
       social: [
         { icon: 'github', label: 'GitHub', href: 'https://github.com/nrwl/nx' },
@@ -136,15 +151,15 @@ export default defineConfig({
           // frequency of the term relative to document length
           // versus weighted term count.
           // default is 1.0
-          termFrequency: 0.75,
+          termFrequency: 0.65,
           // pageLength changes the way ranking compares page lengths with the average page lengths on your site.
           // default 0.75
-          pageLength: 0.5,
+          pageLength: 0.3,
           // termSaturation controls how quickly a term “saturates” on a page.
           // Once a term has appeared on a page many times,
           // further appearances have a reduced impact on the page rank.
           // default: 1.4
-          // termSaturation: 1.4,
+          termSaturation: 1.2,
           // termSimilarity changes the ranking based on
           // similarity of terms to the search query.
           // Currently this only takes the length of the term into account.
@@ -154,5 +169,8 @@ export default defineConfig({
       },
     }),
     react(),
+    sitemap({
+      lastmod: new Date(),
+    }),
   ],
 });

astro-docs/e2e/cli-subcommand-formatting.spec.ts

@@ -0,0 +1,158 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('CLI sub-command formatting', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/docs/reference/nx-commands');
+    await expect(
+      page.getByRole('heading', { name: 'Nx Commands' })
+    ).toBeVisible();
+  });
+
+  test('parent commands render as h2 and sub-commands as h3', async ({
+    page,
+  }) => {
+    const mainContent = page.getByTestId('main-pane');
+
+    // "nx show" should be an h2 (top-level parent command)
+    const showHeading = mainContent.getByRole('heading', {
+      name: 'nx show',
+      level: 2,
+      exact: true,
+    });
+    await expect(showHeading).toBeVisible();
+
+    // "nx show projects" should be an h3 (sub-command nested under parent)
+    const showProjectsHeading = mainContent.getByRole('heading', {
+      name: 'nx show projects',
+      level: 3,
+      exact: true,
+    });
+    await expect(showProjectsHeading).toBeVisible();
+
+    // "nx show project" should also be an h3
+    const showProjectHeading = mainContent.getByRole('heading', {
+      name: 'nx show project',
+      level: 3,
+      exact: true,
+    });
+    await expect(showProjectHeading).toBeVisible();
+  });
+
+  test('sub-command usage blocks show the full command name', async ({
+    page,
+  }) => {
+    const mainContent = page.getByTestId('main-pane');
+
+    // Find the "nx show projects" section and verify its usage block
+    // The usage code block should contain "nx show projects", not "nx projects"
+    const showProjectsHeading = mainContent.getByRole('heading', {
+      name: 'nx show projects',
+      level: 3,
+      exact: true,
+    });
+    await expect(showProjectsHeading).toBeVisible();
+
+    // Get the section between "nx show projects" heading and the next heading.
+    // We look for a code block containing the correct usage pattern.
+    const codeBlocks = mainContent.locator('pre code');
+    const allCodeTexts = await codeBlocks.allTextContents();
+
+    // There should be a usage block with "nx show projects" (full sub-command name)
+    expect(allCodeTexts.some((text) => text.includes('nx show projects'))).toBe(
+      true
+    );
+
+    // There should NOT be a usage block with just "nx projects" (missing parent)
+    expect(
+      allCodeTexts.some(
+        (text) => text.match(/^nx projects/) || text.match(/\nnx projects/)
+      )
+    ).toBe(false);
+  });
+
+  test('nested sub-commands beyond two levels are documented', async ({
+    page,
+  }) => {
+    const mainContent = page.getByTestId('main-pane');
+
+    // "nx show target inputs" is a third-level command — it should render as h3
+    // alongside other sub-commands and include its usage block.
+    const showTargetInputsHeading = mainContent.getByRole('heading', {
+      name: 'nx show target inputs',
+      level: 3,
+      exact: true,
+    });
+    await expect(showTargetInputsHeading).toBeVisible();
+
+    const showTargetOutputsHeading = mainContent.getByRole('heading', {
+      name: 'nx show target outputs',
+      level: 3,
+      exact: true,
+    });
+    await expect(showTargetOutputsHeading).toBeVisible();
+
+    const codeBlocks = mainContent.locator('pre code');
+    const allCodeTexts = await codeBlocks.allTextContents();
+
+    expect(
+      allCodeTexts.some((text) => text.includes('nx show target inputs'))
+    ).toBe(true);
+  });
+
+  test('release sub-commands use correct heading and usage format', async ({
+    page,
+  }) => {
+    const mainContent = page.getByTestId('main-pane');
+
+    // "nx release" should be h2
+    const releaseHeading = mainContent.getByRole('heading', {
+      name: 'nx release',
+      level: 2,
+      exact: true,
+    });
+    await expect(releaseHeading).toBeVisible();
+
+    // "nx release version" should be h3
+    const releaseVersionHeading = mainContent.getByRole('heading', {
+      name: 'nx release version',
+      level: 3,
+      exact: true,
+    });
+    await expect(releaseVersionHeading).toBeVisible();
+
+    // Verify usage block includes the full command
+    const codeBlocks = mainContent.locator('pre code');
+    const allCodeTexts = await codeBlocks.allTextContents();
+
+    expect(
+      allCodeTexts.some((text) => text.includes('nx release version'))
+    ).toBe(true);
+  });
+
+  test('options and examples are h4 headings excluded from the TOC', async ({
+    page,
+  }) => {
+    const mainContent = page.getByTestId('main-pane');
+
+    // Options/Examples should be h4 headings — linkable but below the TOC threshold (h2-h3)
+    const sharedOptionsHeading = mainContent.getByRole('heading', {
+      name: 'Shared Options',
+      level: 4,
+    });
+    await expect(sharedOptionsHeading.first()).toBeVisible();
+
+    const optionsHeading = mainContent.getByRole('heading', {
+      name: 'Options',
+      level: 4,
+    });
+    await expect(optionsHeading.first()).toBeVisible();
+
+    // They should NOT appear as h2 or h3 (which would put them in the TOC)
+    await expect(
+      mainContent.getByRole('heading', { name: 'Options', level: 2 })
+    ).toHaveCount(0);
+    await expect(
+      mainContent.getByRole('heading', { name: 'Options', level: 3 })
+    ).toHaveCount(0);
+  });
+});

astro-docs/e2e/devkit-urls-fragments.spec.ts

@@ -11,7 +11,7 @@ test('links in descriptions of properties should correctly link to the same page
 
   await page
     .getByTestId('main-pane')
-    .getByRole('link', { name: 'nxCloudAccessToken' })
+    .getByRole('link', { name: 'nxCloudAccessToken', exact: true })
     .click();
 
   await expect(

astro-docs/eslint.config.mjs

@@ -0,0 +1,24 @@
+import { baseConfig } from '../eslint.config.mjs';
+import playwright from 'eslint-plugin-playwright';
+
+export default [
+  ...baseConfig,
+  playwright.configs['flat/recommended'],
+  {
+    files: ['**/*.spec.ts', '**/*.test.ts', '**/*.spec.js', '**/*.test.js'],
+    rules: {
+      'playwright/no-standalone-expect': 'off',
+    },
+  },
+  {
+    ignores: [
+      'node_modules/',
+      'dist/',
+      '.astro/',
+      '.netlify/',
+      'test-output/',
+      'playwright-report/',
+      'src/content/banner.json',
+    ],
+  },
+];

astro-docs/markdoc.config.mjs

@@ -4,9 +4,15 @@ import {
   Markdoc,
 } from '@astrojs/markdoc/config';
 import starlightMarkdoc from '@astrojs/starlight-markdoc';
+import { transformOptionsTable } from './src/utils/markdoc-table-option-links';
 
 export default defineMarkdocConfig({
   extends: [starlightMarkdoc()],
+  nodes: {
+    table: {
+      transform: transformOptionsTable,
+    },
+  },
   tags: {
     call_to_action: {
       render: component('./src/components/markdoc/CallToAction.astro'),
@@ -238,6 +244,15 @@ export default defineMarkdocConfig({
         },
       },
     },
+    sidebar_group_cards: {
+      render: component('./src/components/markdoc/SidebarGroupCards.astro'),
+      attributes: {
+        group: {
+          type: 'String',
+          required: true,
+        },
+      },
+    },
     metrics: {
       render: component('./src/components/markdoc/Metrics.astro'),
       attributes: {
@@ -402,6 +417,65 @@ export default defineMarkdocConfig({
         },
       },
     },
+    llm_copy_prompt: {
+      render: component('./src/components/markdoc/LlmCopyPrompt.astro'),
+      attributes: {
+        title: { type: 'String', required: true },
+      },
+      children: ['paragraph', 'tag', 'list'],
+      transform(node, config) {
+        const attributes = node.transformAttributes(config);
+        function extractText(n, listContext) {
+          if (typeof n === 'string') return n;
+          if (n.type === 'text' || n.type === 'softbreak')
+            return n.attributes?.content ?? '\n';
+          if (n.type === 'code')
+            return '`' + (n.attributes?.content ?? '') + '`';
+          if (n.type === 'link') {
+            const inner = (n.children || [])
+              .map((c) => extractText(c))
+              .join('');
+            const href = n.attributes?.href;
+            return href ? `${inner} (${href})` : inner;
+          }
+          if (n.type === 'inline')
+            return (n.children || []).map((c) => extractText(c)).join('');
+          if (n.type === 'paragraph')
+            return (
+              (n.children || []).map((c) => extractText(c)).join('') + '\n'
+            );
+          if (n.type === 'list') {
+            const ordered = n.attributes?.ordered === true;
+            return (
+              (n.children || [])
+                .map((c, i) => extractText(c, { ordered, index: i + 1 }))
+                .join('\n') + '\n'
+            );
+          }
+          if (n.type === 'item') {
+            const prefix =
+              listContext?.ordered === true ? `${listContext.index}. ` : '- ';
+            return (
+              prefix + (n.children || []).map((c) => extractText(c)).join('')
+            );
+          }
+          if (n.children) return n.children.map((c) => extractText(c)).join('');
+          return '';
+        }
+        const promptText = node.children
+          .map((c) => extractText(c))
+          .join('\n')
+          .trim();
+        return new Markdoc.Tag(this.render, { ...attributes, promptText }, []);
+      },
+    },
+    llm_only: {
+      attributes: {},
+      children: ['paragraph', 'tag', 'list'],
+      transform() {
+        return null;
+      },
+    },
     youtube: {
       render: component('./src/components/markdoc/Youtube.astro'),
       attributes: {