format: apply repo prettier (3.8.1) to the folded skills tree

963 markdown files reformatted with the repository's pinned prettier so
pnpm format:check covers the folded tree like every other repo file.

The formatter's embedded-language pass also normalized code fences
(TS semicolons, closed HTML tags in examples, lowercased CSS hex colors,
one renumbered list that skipped an index). Alphanumeric token deltas vs
the fold commit were audited file-by-file; all are formatter-equivalent
markup normalizations plus the four sanitized skills.

packages/mosaic/framework/skills/algorithmic-art/SKILL.md

@@ -7,6 +7,7 @@ license: Complete terms in LICENSE.txt
 Algorithmic philosophies are computational aesthetic movements that are then expressed through code. Output .md files (philosophy), .html files (interactive viewer), and .js files (generative algorithms).
 
 This happens in two steps:
+
 1. Algorithmic Philosophy Creation (.md file)
 2. Express by creating p5.js generative art (.html + .js files)
 
@@ -15,17 +16,20 @@ First, undertake this task:
 ## ALGORITHMIC PHILOSOPHY CREATION
 
 To begin, create an ALGORITHMIC PHILOSOPHY (not static images or templates) that will be interpreted through:
+
 - Computational processes, emergent behavior, mathematical beauty
 - Seeded randomness, noise fields, organic systems
 - Particles, flows, fields, forces
 - Parametric variation and controlled chaos
 
 ### THE CRITICAL UNDERSTANDING
+
 - What is received: Some subtle input or instructions by the user to take into account, but use as a foundation; it should not constrain creative freedom.
 - What is created: An algorithmic philosophy/generative aesthetic movement.
 - What happens next: The same version receives the philosophy and EXPRESSES IT IN CODE - creating p5.js sketches that are 90% algorithmic generation, 10% essential parameters.
 
 Consider this approach:
+
 - Write a manifesto for a generative art movement
 - The next phase involves writing the algorithm that brings it to life
 
@@ -38,6 +42,7 @@ The philosophy must emphasize: Algorithmic expression. Emergent behavior. Comput
 **Articulate the philosophy** (4-6 paragraphs - concise but complete):
 
 To capture the ALGORITHMIC essence, express how this philosophy manifests through:
+
 - Computational processes and mathematical relationships?
 - Noise functions and randomness patterns?
 - Particle behaviors and field dynamics?
@@ -45,6 +50,7 @@ To capture the ALGORITHMIC essence, express how this philosophy manifests throug
 - Parametric variation and emergent complexity?
 
 **CRITICAL GUIDELINES:**
+
 - **Avoid redundancy**: Each algorithmic aspect should be mentioned once. Avoid repeating concepts about noise theory, particle dynamics, or mathematical principles unless adding new depth.
 - **Emphasize craftsmanship REPEATEDLY**: The philosophy MUST stress multiple times that the final algorithm should appear as though it took countless hours to develop, was refined with care, and comes from someone at the absolute top of their field. This framing is essential - repeat phrases like "meticulously crafted algorithm," "the product of deep computational expertise," "painstaking optimization," "master-level implementation."
 - **Leave creative space**: Be specific about the algorithmic direction, but concise enough that the next Claude has room to make interpretive implementation choices at an extremely high level of craftsmanship.
@@ -73,9 +79,10 @@ Algorithmic expression: Vector fields constructed from mathematical functions or
 Philosophy: Random processes crystallizing into ordered structures.
 Algorithmic expression: Randomized circle packing or Voronoi tessellation. Start with random points, let them evolve through relaxation algorithms. Cells push apart until equilibrium. Color based on cell size, neighbor count, or distance from center. The organic tiling that emerges feels both random and inevitable. Every seed produces unique crystalline beauty - the mark of a master-level generative algorithm.
 
-*These are condensed examples. The actual algorithmic philosophy should be 4-6 substantial paragraphs.*
+_These are condensed examples. The actual algorithmic philosophy should be 4-6 substantial paragraphs._
 
 ### ESSENTIAL PRINCIPLES
+
 - **ALGORITHMIC PHILOSOPHY**: Creating a computational worldview to be expressed through code
 - **PROCESS OVER PRODUCT**: Always emphasize that beauty emerges from the algorithm's execution - each run is unique
 - **PARAMETRIC EXPRESSION**: Ideas communicate through mathematical relationships, forces, behaviors - not static composition
@@ -113,12 +120,14 @@ With the philosophy AND conceptual framework established, express it through cod
 5. **Replace only the VARIABLE sections** marked in the file's comments (algorithm, parameters, UI controls for parameters)
 
 **Avoid:**
+
 - ❌ Creating HTML from scratch
 - ❌ Inventing custom styling or color schemes
 - ❌ Using system fonts or dark themes
 - ❌ Changing the sidebar structure
 
 **Follow these practices:**
+
 - ✅ Copy the template's exact HTML structure
 - ✅ Keep Anthropic branding (Poppins/Lora fonts, light colors, gradient backdrop)
 - ✅ Maintain the sidebar layout (Seed → Parameters → Colors? → Actions)
@@ -133,6 +142,7 @@ To create gallery-quality computational art that lives and breathes, use the alg
 ### TECHNICAL REQUIREMENTS
 
 **Seeded Randomness (Art Blocks Pattern)**:
+
 ```javascript
 // ALWAYS use a seed for reproducibility
 let seed = 12345; // or hash from user input
@@ -146,7 +156,7 @@ To establish parameters that emerge naturally from the algorithmic philosophy, c
 
 ```javascript
 let params = {
-  seed: 12345,  // Always include seed for reproducibility
+  seed: 12345, // Always include seed for reproducibility
   // colors
   // Add parameters that control YOUR algorithm:
   // - Quantities (how many?)
@@ -167,16 +177,19 @@ let params = {
 To express the philosophy through code, avoid thinking "which pattern should I use?" and instead think "how to express this philosophy through code?"
 
 If the philosophy is about **organic emergence**, consider using:
+
 - Elements that accumulate or grow over time
 - Random processes constrained by natural rules
 - Feedback loops and interactions
 
 If the philosophy is about **mathematical beauty**, consider using:
+
 - Geometric relationships and ratios
 - Trigonometric functions and harmonics
 - Precise calculations creating unexpected patterns
 
 If the philosophy is about **controlled chaos**, consider using:
+
 - Random variation within strict boundaries
 - Bifurcation and phase transitions
 - Order emerging from disorder
@@ -186,6 +199,7 @@ If the philosophy is about **controlled chaos**, consider using:
 To guide the implementation, let the conceptual essence inform creative and original choices. Build something that expresses the vision for this particular request.
 
 **Canvas Setup**: Standard p5.js structure:
+
 ```javascript
 function setup() {
   createCanvas(1200, 1200);
@@ -211,6 +225,7 @@ function draw() {
 ### OUTPUT FORMAT
 
 Output:
+
 1. **Algorithmic Philosophy** - As markdown or text explaining the generative aesthetic
 2. **Single HTML Artifact** - Self-contained interactive generative art built from `templates/viewer.html` (see STEP 0 and next section)
 
@@ -229,6 +244,7 @@ To allow exploration of the generative art, create a single, self-contained HTML
 The `templates/viewer.html` file is the foundation. It contains the exact structure and styling needed.
 
 **FIXED (always include exactly as shown):**
+
 - Layout structure (header, sidebar, main canvas area)
 - Anthropic branding (UI colors, fonts, gradients)
 - Seed section in sidebar:
@@ -241,6 +257,7 @@ The `templates/viewer.html` file is the foundation. It contains the exact struct
   - Reset button
 
 **VARIABLE (customize for each artwork):**
+
 - The entire p5.js algorithm (setup/draw/classes)
 - The parameters object (define what the art needs)
 - The Parameters section in sidebar:
@@ -259,12 +276,14 @@ The `templates/viewer.html` file is the foundation. It contains the exact struct
 ### REQUIRED FEATURES
 
 **1. Parameter Controls**
+
 - Sliders for numeric parameters (particle count, noise scale, speed, etc.)
 - Color pickers for palette colors
 - Real-time updates when parameters change
 - Reset button to restore defaults
 
 **2. Seed Navigation**
+
 - Display current seed number
 - "Previous" and "Next" buttons to cycle through seeds
 - "Random" button for random seed
@@ -272,30 +291,31 @@ The `templates/viewer.html` file is the foundation. It contains the exact struct
 - Generate 100 variations when requested (seeds 1-100)
 
 **3. Single Artifact Structure**
+
 ```html
 <!DOCTYPE html>
 <html>
-<head>
-  <!-- p5.js from CDN - always available -->
-  <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js"></script>
-  <style>
-    /* All styling inline - clean, minimal */
-    /* Canvas on top, controls below */
-  </style>
-</head>
-<body>
-  <div id="canvas-container"></div>
-  <div id="controls">
-    <!-- All parameter controls -->
-  </div>
-  <script>
-    // ALL p5.js code inline here
-    // Parameter objects, classes, functions
-    // setup() and draw()
-    // UI handlers
-    // Everything self-contained
-  </script>
-</body>
+  <head>
+    <!-- p5.js from CDN - always available -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.7.0/p5.min.js"></script>
+    <style>
+      /* All styling inline - clean, minimal */
+      /* Canvas on top, controls below */
+    </style>
+  </head>
+  <body>
+    <div id="canvas-container"></div>
+    <div id="controls">
+      <!-- All parameter controls -->
+    </div>
+    <script>
+      // ALL p5.js code inline here
+      // Parameter objects, classes, functions
+      // setup() and draw()
+      // UI handlers
+      // Everything self-contained
+    </script>
+  </body>
 </html>
 ```
 
@@ -306,30 +326,44 @@ The `templates/viewer.html` file is the foundation. It contains the exact struct
 The sidebar structure:
 
 **1. Seed (FIXED)** - Always include exactly as shown:
+
 - Seed display
 - Prev/Next/Random/Jump buttons
 
 **2. Parameters (VARIABLE)** - Create controls for the art:
+
 ```html
 <div class="control-group">
-    <label>Parameter Name</label>
-    <input type="range" id="param" min="..." max="..." step="..." value="..." oninput="updateParam('param', this.value)">
-    <span class="value-display" id="param-value">...</span>
+  <label>Parameter Name</label>
+  <input
+    type="range"
+    id="param"
+    min="..."
+    max="..."
+    step="..."
+    value="..."
+    oninput="updateParam('param', this.value)"
+  />
+  <span class="value-display" id="param-value">...</span>
 </div>
 ```
+
 Add as many control-group divs as there are parameters.
 
 **3. Colors (OPTIONAL/VARIABLE)** - Include if the art needs adjustable colors:
+
 - Add color pickers if users should control palette
 - Skip this section if the art uses fixed colors
 - Skip if the art is monochrome
 
 **4. Actions (FIXED)** - Always include exactly as shown:
+
 - Regenerate button
 - Reset button
 - Download PNG button
 
 **Requirements**:
+
 - Seed controls must work (prev/next/random/jump/display)
 - All parameters must have UI controls
 - Regenerate, Reset, Download buttons must work
@@ -338,6 +372,7 @@ Add as many control-group divs as there are parameters.
 ### USING THE ARTIFACT
 
 The HTML artifact works immediately:
+
 1. **In claude.ai**: Displayed as an interactive artifact - runs instantly
 2. **As a file**: Save and open in any browser - no server needed
 3. **Sharing**: Send the HTML file - it's completely self-contained
@@ -369,11 +404,13 @@ Each request is unique. The process involves:
 5. **Build matching UI controls** - Sliders/inputs for those parameters
 
 **The constants**:
+
 - Anthropic branding (colors, fonts, layout)
 - Seed navigation (always present)
 - Self-contained HTML artifact
 
 **Everything else is variable**:
+
 - The algorithm itself
 - The parameters
 - The UI controls
@@ -399,7 +436,8 @@ This skill includes helpful templates and documentation:
   - Embed algorithms inline in the HTML artifact (don't create separate .js files)
 
 **Critical reminder**:
+
 - The **template is the STARTING POINT**, not inspiration
 - The **algorithm is where to create** something unique
 - Don't copy the flow field example - build what the philosophy demands
-- But DO keep the exact UI structure and Anthropic branding from the template
+- But DO keep the exact UI structure and Anthropic branding from the template