Feat/css tranformer cli

.agents/skills/orchestrator-implementer-judge-loop/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: "orchestrator-implementer-judge-loop"
+description: "Strict orchestration workflow for engineering tasks that must be solved one numbered problem at a time through an explicit cycle: define the current problem, build a Robust Code strategy, delegate the work to an implementer with the current situation and exact solution method, send the result to a judge with the audit target and audit criteria, repeat implementation and judgment until defects are closed, then issue a final orchestrator verdict before moving to the next problem. Use when Codex must run a deterministic orchestrator-to-implementer-to-judge regression loop with bounded scope, explicit packets, and no ambiguity."
+---
+
+# Orchestrator Implementer Judge Loop
+
+## Core Role
+
+Act as `[OMNISCIENT ORCHESTRATOR]`.
+Solve one numbered problem at a time.
+Finish the full cycle for the current problem before touching the next problem.
+Base every strategy on `robust-code`: explicit assumptions, minimal change, bounded scope, and verifiable success criteria.
+Stop and ask the user when a requirement is ambiguous, architectural, or irreversible.
+
+## Mandatory Cycle
+
+For each numbered problem, execute the following order without skipping or merging steps.
+
+### 1. Define the current problem
+
+State the exact symptom.
+State the scope boundary.
+State the constraints.
+State the desired end state.
+State the proof required to close the problem.
+Split the work into the smallest task that can be implemented and audited safely.
+
+### 2. Build the Robust Code strategy
+
+Produce a short `Robust Code Strategy` with:
+
+- Current problem situation
+- Minimal fix or implementation direction
+- In-scope files or modules
+- Out-of-scope work
+- Feature-case verification
+- Complex edge-case verification
+- Rejection conditions
+
+### 3. Delegate to `[OMNISCIENT IMPLEMENTER]`
+
+Send the work in this exact structure:
+
+```text
+[IMPLEMENTER PACKET]
+Problem:
+Current situation:
+Goal:
+Exact implementation method:
+In-scope files or modules:
+Out-of-scope changes:
+Verification to satisfy:
+Completion signal:
+```
+
+Require the implementer to change only what is necessary.
+Require the implementer to return concrete completion evidence.
+Do not allow the implementer to declare the task accepted.
+
+### 4. Receive the implementation result
+
+Collect the changed artifact.
+Collect test or verification evidence.
+Collect unresolved risks.
+Treat the result as `implemented`, not `accepted`.
+
+### 5. Delegate to `[OMNISCIENT JUDGE]`
+
+Send the audit in this exact structure:
+
+```text
+[JUDGE PACKET]
+Problem:
+Audit target:
+Audit criteria:
+Required evidence:
+Rejection rule:
+Output format:
+```
+
+Set `Output format` to `PASS` or `FAIL` plus a numbered defect list.
+Require the judge to evaluate only against the stated criteria unless a critical defect is discovered.
+
+### 6. Run the defect loop
+
+If the judge returns `FAIL`, convert each defect into a precise rework order.
+Re-send an updated implementer packet that includes:
+
+- Defect number
+- Observed failure
+- Violated criterion
+- Exact correction required
+- Regression guard
+
+Return to Step 4 after re-implementation.
+Repeat the implementation and judgment loop until the judge returns `PASS`.
+
+### 7. Issue the final orchestrator verdict
+
+Re-check the accepted result yourself.
+Confirm that the problem is truly closed.
+Confirm that the required verification evidence exists.
+Only after the final verdict passes, move to the next numbered problem.
+
+## Hard Rules
+
+- Never merge strategy, implementation, and judgment into one step.
+- Never move to the next problem on a provisional pass.
+- Never send vague feedback such as `improve this` or `clean this up`.
+- Never allow the implementer to self-approve.
+- Never allow the judge to implement the fix it is auditing.
+- Never accept unrelated refactors during a defect loop.
+- Always preserve previously passing behavior while fixing defects.
+- Always make the audit criteria explicit enough that a third party can reproduce the verdict.
+
+## Required Per-Problem Artifacts
+
+Keep the following artifacts visible for each problem:
+
+- Problem definition
+- Robust Code strategy
+- Implementer packet
+- Judge packet
+- Defect ledger
+- Final orchestrator verdict
+
+## Execution Mode
+
+Use real delegation when the environment and the user request permit subagents or distinct workers.
+If literal delegation is unavailable, emulate the same separation in ordered sections and do not collapse the acceptance gate.
+Maintain role separation even in a single-thread execution.
+
+## Minimal Output Frame
+
+Use this frame when the task needs a visible control surface:
+
+```text
+[PROBLEM n]
+Status: OPEN | IN-LOOP | PASSED
+
+[ROBUST CODE STRATEGY]
+...
+
+[IMPLEMENTER PACKET]
+...
+
+[JUDGE PACKET]
+...
+
+[DEFECT LEDGER]
+...
+
+[FINAL ORCHESTRATOR VERDICT]
+...
+```

.agents/skills/orchestrator-implementer-judge-loop/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Orchestrator Judge Loop"
+  short_description: "Strict implementer and judge task cycle"
+  default_prompt: "Use $orchestrator-implementer-judge-loop to run each task through strategy, implementation, judgment, and regression until final pass."

.agents/skills/robust-code/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: robust-code
+description: Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
+---
+
+# Robust Code Writing Guidelines
+
+> **Tradeoff:** These guidelines bias toward caution over speed. For trivial tasks, use judgment.
+
+## 1. Think Before Coding
+
+**Don't assume. Don't hide confusion. Surface tradeoffs.**
+
+Before implementing:
+
+- State your assumptions explicitly. If uncertain, ask.
+- If multiple interpretations exist, present them - don't pick silently.
+- If a simpler approach exists, say so. Push back when warranted.
+- If something is unclear, stop. Name what's confusing. Ask.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Loop until verified.**
+
+Transform tasks into verifiable goals:
+
+- "Add validation" → "Write tests for invalid inputs, then make them pass"
+- "Fix the bug" → "Write a test that reproduces it, then make it pass"
+- "Refactor X" → "Ensure tests pass before and after"
+
+For multi-step tasks, state a brief plan:
+
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.
+
+## 5. Validate Using Unit Tests.
+
+1. Write down module's all feature case test code.
+   If this test passed, move to next phase.
+2. Write down module's complex-edge case test code.
+   This part, we can confirm that our objective is completed correctly.

.changeset/config.json

@@ -4,7 +4,7 @@
     "commit": false,
     "fixed": [],
     "linked": [],
-    "ignore": ["tailwindest-documentation"],
+    "ignore": ["web"],
     "access": "restricted",
     "baseBranch": "master",
     "updateInternalDependencies": "patch"

.prettierignore

@@ -1,2 +1,3 @@
 /node_modules/*
 pnpm-lock.yaml
+**/.next/*