claude-code-kit 0.54.0__tar.gz → 0.56.0__tar.gz

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "claude-kit",
       "source": "./",
       "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker): install CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json, then run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.",
-      "version": "0.54.0",
+      "version": "0.56.0",
       "license": "MIT",
       "keywords": ["sdlc", "agents", "orchestration", "quality-gates", "workflow", "scaffold", "cookiecutter"]
     }

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-kit",
-  "version": "0.54.0",
+  "version": "0.56.0",
   "description": "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC config (no app code, no Docker). `claude-kit init` asks ordered questions and installs CLAUDE.md + .claude/ (rules, the profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates with working memory and a self-improving learnings loop.",
   "author": {
     "name": "Arjunsingh Yadav",

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/.gitignore

@@ -28,3 +28,9 @@ zap-vapt-tool.zip
 # depth, and on case-insensitive filesystems (macOS default) it also swallows
 # rules/continuity.md — the tracked rule file.
 .claude/
+
+# Local-only working artifacts — generated during development, never part of the distributable kit.
+# (Review write-ups, ad-hoc patches, and locally-gathered reference data.)
+claude-kit-review*.md
+*.patch
+ai_repos_over_40k_stars.*

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/CHANGELOG.md

@@ -4,6 +4,66 @@ All notable changes to claude-kit are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/), and the project uses
 [semantic versioning](https://semver.org/).
 
+## [0.56.0] — 2026-07-01
+
+**`export` command — carry the config to Cursor / VS Code / GitHub Copilot.** A teammate who works in
+an editor that isn't Claude Code can't consume `.claude/` or run the gated `/sdlc` pipeline. `claude-kit
+export` projects the **same resolved plan** into the formats those single-agent editors read natively,
+so claude-kit's standards travel even where the pipeline can't. No change to the core promise —
+configuration-only SDLC scaffolding for Claude Code, no application code, no Docker, stack-agnostic
+core, catalog-driven. **0 new agents/skills**; `catalog.resolve()` untouched (a pure projection of the
+existing plan).
+
+### Added
+
+- **`claude-kit export [path] -t cursor|agents|copilot`.** Re-targets the resolved `ResolvedPlan` to:
+  - **`cursor`** — `.cursor/rules/*.mdc` (one per rule, with YAML frontmatter derived generically from
+    each rule: `description` = H1 + lead sentence; `alwaysApply: false` for the on-demand rule set;
+    overlay rules get `globs` keyed on the plan's *language/database* values — `typescript` →
+    `**/*.ts,**/*.tsx`, `python` → `**/*.py`, `postgres` → `**/*.sql`, …), an always-applied
+    `000-project.mdc` charter, and `.cursor/mcp.json` (the `type` discriminator stripped for Cursor).
+  - **`agents`** — a root `AGENTS.md` (charter + single-agent SDLC checklist + rule index + fidelity
+    note); read by both Cursor and Copilot.
+  - **`copilot`** — `.github/copilot-instructions.md` (the same synthesized document as `agents`).
+- **Honest fidelity, everywhere.** Rules, the project charter, and MCP port cleanly; the **enforced**
+  quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only and are
+  exported as a single-agent **self-check checklist**. Every exported document states this explicitly
+  (a "What ports from Claude Code — and what doesn't" note + the workflow guide's opening).
+- **Flags mirror `init`:** `--dry-run` (report, write nothing), `--force` (refresh in place; otherwise
+  a hand-edited file is preserved and the new version lands beside it as a `.claude-kit` sidecar),
+  `--config`/`--defaults` (resolve a fresh selection instead of the project's installed one), `--json`.
+- **New payload template** `templates/export/sdlc-workflow-guide.md.tmpl` (stack-agnostic; renders with
+  the project's real test/lint/build commands), plus `tests/test_export.py` and
+  [`docs/cursor-export.md`](docs/cursor-export.md) (usage + the full fidelity matrix).
+
+## [0.55.0] — 2026-07-01
+
+**React overlay rules split under Claude Code's 40k memory limit.** Two React design-system overlay
+rules shipped over the 40,000-character memory/rule-file limit, so every React scaffold saw the
+`over the 40.0k-char limit · /memory` warning and risked the rule loading only partially. They are now
+split by concern — 100% of content preserved verbatim — and a CI guard keeps any rule from regressing.
+No change to the core promise — configuration-only SDLC scaffolding for Claude Code, no application
+code, no Docker, stack-agnostic core, catalog-driven. **0 new agents/skills.**
+
+### Fixed
+
+- **Oversized React overlay rules split under the 40k limit.** `ui-design-system.md` (56.7k) → the
+  foundations/index `ui-design-system.md` + `ui-components.md` (cards, badges, buttons, form controls,
+  states, tooltips, KPI labels, data tables, compound components) + `ui-layout-and-motion.md` (page
+  layout, motion, accessibility, page blueprints, quick reference); `ux-patterns.md` (44.4k) → the
+  content/interaction `ux-patterns.md` + `ux-dashboard-patterns.md` (chart standards, tab bar, KPI-grid
+  layouts, global filter strip). Every shipped rule file is now well under the limit. The React
+  `overlay_rules` list (`catalog/stacks.yaml`) grows 5 → 8; cross-references in `react-patterns.md`,
+  `mobile-design-guidelines.md`, and `design-system-compliance.md`, and the `ui-ux-design` /
+  `component-design` skills + `ui-designer` agent, all repoint to the split files.
+
+### Added
+
+- **`scripts/check_rule_sizes.py` regression guard.** Scans every shipped rule file (`rules/*.md`,
+  `templates/stacks/**/rules/*.md`, `templates/org/rules/*.md`) and fails if any reaches 38,000
+  characters (2k of headroom under the 40k hard limit). Wired into CI next to the MCP-pin gate and
+  covered by `tests/test_rule_sizes.py`.
+
 ## [0.54.0] — 2026-06-29
 
 **Safety, correctness, and capability hardening pass.** Two reviews (a fresh practical review and an

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: claude-code-kit
-Version: 0.54.0
+Version: 0.56.0
 Summary: Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop.
 Project-URL: Homepage, https://github.com/ajyadav013/claude-kit
 Project-URL: Repository, https://github.com/ajyadav013/claude-kit
@@ -236,6 +236,36 @@ README.claude-sdlc.md
 
 ---
 
+## Use in Cursor / VS Code / Copilot (export)
+
+A teammate who works in **Cursor**, **VS Code**, or **GitHub Copilot** can't consume `.claude/` or run
+the gated multi-agent `/sdlc` pipeline — those editors drive their own single agent. `claude-kit
+export` projects the **same resolved plan** into the formats those agents read natively, so the
+standards travel even when the pipeline can't:
+
+```bash
+claude-kit export .                              # → .cursor/ (default target)
+claude-kit export . -t cursor -t agents -t copilot   # all three at once
+claude-kit export . --dry-run                    # preview; writes nothing
+```
+
+| Target | Emits | What lands |
+|---|---|---|
+| `cursor` | `.cursor/rules/*.mdc` + `.cursor/mcp.json` | The full rule set (one on-demand `.mdc` each, overlays auto-attach by file glob), an always-applied `000-project.mdc` charter, and your MCP servers |
+| `agents` | `AGENTS.md` (repo root) | Project charter + single-agent SDLC checklist + rule index (read by Cursor **and** Copilot) |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents` |
+
+**Fidelity is honest.** Rules, the project charter, and MCP servers port cleanly. The **enforced**
+quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only — the
+export carries the SDLC workflow as a **single-agent self-check checklist**, not enforced gates. Every
+exported document says so. Exports are regenerable projections: `--force` refreshes them in place, and
+without it a hand-edited file is preserved (the new version drops beside it as a `.claude-kit` sidecar).
+
+See **[docs/cursor-export.md](docs/cursor-export.md)** for the full fidelity matrix and the `.mdc`
+frontmatter mapping.
+
+---
+
 ## Feature details
 
 Each area from the [Features](#features) table, expanded — the README stays short; open only what you
@@ -724,6 +754,7 @@ everything available.
 | `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
 | `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
+| `export [path] -t cursor\|agents\|copilot [--force] [--dry-run] [--json]` | Project the config into Cursor (`.cursor/`), a root `AGENTS.md`, or GitHub Copilot (`.github/copilot-instructions.md`) for editors that aren't Claude Code |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
 | `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/README.md

@@ -203,6 +203,36 @@ README.claude-sdlc.md
 
 ---
 
+## Use in Cursor / VS Code / Copilot (export)
+
+A teammate who works in **Cursor**, **VS Code**, or **GitHub Copilot** can't consume `.claude/` or run
+the gated multi-agent `/sdlc` pipeline — those editors drive their own single agent. `claude-kit
+export` projects the **same resolved plan** into the formats those agents read natively, so the
+standards travel even when the pipeline can't:
+
+```bash
+claude-kit export .                              # → .cursor/ (default target)
+claude-kit export . -t cursor -t agents -t copilot   # all three at once
+claude-kit export . --dry-run                    # preview; writes nothing
+```
+
+| Target | Emits | What lands |
+|---|---|---|
+| `cursor` | `.cursor/rules/*.mdc` + `.cursor/mcp.json` | The full rule set (one on-demand `.mdc` each, overlays auto-attach by file glob), an always-applied `000-project.mdc` charter, and your MCP servers |
+| `agents` | `AGENTS.md` (repo root) | Project charter + single-agent SDLC checklist + rule index (read by Cursor **and** Copilot) |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents` |
+
+**Fidelity is honest.** Rules, the project charter, and MCP servers port cleanly. The **enforced**
+quality gates, independent reviewer subagents, and automated defect loop are Claude-Code-only — the
+export carries the SDLC workflow as a **single-agent self-check checklist**, not enforced gates. Every
+exported document says so. Exports are regenerable projections: `--force` refreshes them in place, and
+without it a hand-edited file is preserved (the new version drops beside it as a `.claude-kit` sidecar).
+
+See **[docs/cursor-export.md](docs/cursor-export.md)** for the full fidelity matrix and the `.mdc`
+frontmatter mapping.
+
+---
+
 ## Feature details
 
 Each area from the [Features](#features) table, expanded — the README stays short; open only what you
@@ -691,6 +721,7 @@ everything available.
 | `validate [path] [--strict]` | Structurally validate an installed config; `--strict` adds hooks→script, `.mcp.json`-shape, snapshot, and catalog-integrity checks |
 | `doctor [path] [--mcp]` | Strict validate + environment/health checks; `--mcp` checks MCP commands, `${ENV}` vars, and lockfile drift |
 | `diff [path]` | Preview what an `upgrade` would change (no writes) |
+| `export [path] -t cursor\|agents\|copilot [--force] [--dry-run] [--json]` | Project the config into Cursor (`.cursor/`), a root `AGENTS.md`, or GitHub Copilot (`.github/copilot-instructions.md`) for editors that aren't Claude Code |
 | `upgrade [path] [--force]` | Refresh kit/overlay files; protect your edits; prune orphans |
 | `pipeline validate · status · close-gate · abort` | Inspect/mutate the `/sdlc` state files (gate/lane/evidence coherence); **does not run** the pipeline |
 | `list-options` | List available frontend/backend/database/profile/MCP options |

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/agents/ui-designer.md

@@ -19,7 +19,7 @@ For any frontend, UI, or interaction work, produce a **complete, production-read
 Your project's frontend stack may vary. Before designing, identify:
 - The UI framework (e.g., React, Vue, Svelte, Angular, vanilla JS)
 - The styling approach (e.g., CSS modules, Tailwind, styled-components, CSS-in-JS)
-- Design system location (if one exists — check `.claude/rules/ui-design-system.md` (React overlay), `docs/references/ui/`, `design-system/`, or similar)
+- Design system location (if one exists — check `.claude/rules/ui-design-system.md` (React overlay; its `ui-components.md` / `ui-layout-and-motion.md` companions cover components and layout/motion/a11y), `docs/references/ui/`, `design-system/`, or similar)
 - Component library path (check `src/components/`, `lib/ui/`, or similar)
 
 ## MANDATORY: Read Before Designing

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/catalog/stacks.yaml

@@ -24,7 +24,7 @@ frontend:
       languages:
         default: typescript
         options: [typescript, javascript]
-      overlay_rules: [react-patterns.md, design-system-compliance.md, ui-design-system.md, ux-patterns.md, mobile-design-guidelines.md]
+      overlay_rules: [react-patterns.md, design-system-compliance.md, ui-design-system.md, ui-components.md, ui-layout-and-motion.md, ux-patterns.md, ux-dashboard-patterns.md, mobile-design-guidelines.md]
       overlay_agents: []
       skills: [frontend-ui-engineering, component-design, ui-ux-design, unit-test]
       stack_dir: frontend/react

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/docs/architecture.md

@@ -75,6 +75,17 @@ flowchart TB
 Adding a framework/database/profile/MCP server is a **catalog edit + a `templates/stacks/` folder** —
 never a change to `resolve()`.
 
+### Same plan, second target: `export` (for non-Claude-Code editors)
+
+The `ResolvedPlan` is the reuse seam. `claude-kit export` (`src/claude_kit/export.py`) takes the **same**
+plan and, instead of `scaffold.install_sdlc()` writing `.claude/`, projects it into the formats a
+single-agent editor reads natively — `.cursor/rules/*.mdc` + `.cursor/mcp.json` (Cursor), a root
+`AGENTS.md`, or `.github/copilot-instructions.md` (Copilot). It is a pure projection: it adds no stack
+knowledge, and `catalog.resolve()` gains no branches (golden rules #1 and #6). Fidelity is asymmetric
+and stated in every exported file — rules, the charter, and MCP port cleanly, while the *enforced*
+gates and reviewer subagents become single-agent guidance. See
+[cursor-export.md](cursor-export.md) for the full mapping.
+
 ---
 
 ## 3. The SDLC pipeline (run)

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/docs/coverage-audit.md

@@ -70,7 +70,7 @@ checklists that ride *inside existing* review gates. Enforcement class of each:
 | **Suite-architecture audit** | **AGENT mode — standard+** | `suite-audit` mode on `agents/senior-tester`; a verification *mode*, not a separate token | advisory (within testing) |
 | **Staff-PM product-lens review tier** | **SKILL/AGENT — organization scope only** | `staff-pm-reviewer` + `review-scope`/`review-sprint-plan`/`review-ux-flow`/`review-sprint` install only when `scope == organization` (`catalog/org.yaml`); read-only, advisory — no product gate token | org scope (advisory) |
 | **Design-system compliance · a11y/contract overlay enrichments** | **OVERLAY RULE** | `design-system-compliance.md` + enrichments in `react-patterns.md`/`fastapi-patterns.md`; install only when the matching stack is selected | when stack selected (advisory rule) |
-| **Design system · UX patterns · mobile guidelines** (0.16.0) | **OVERLAY RULE — React-gated, always-on, advisory** | `ui-design-system.md` / `ux-patterns.md` / `mobile-design-guidelines.md` (React `overlay_rules`); install into `.claude/rules/` only when React is selected, then load every session. The authoritative source for `design-system-compliance.md`'s thin pointer and `react-patterns.md`'s trimmed a11y cross-ref; consumed by the `ui-ux-design` / `component-design` skills + `ui-designer` agent | when React selected (advisory rule) |
+| **Design system · UX patterns · mobile guidelines** (0.16.0; split under the 40k limit in 0.55.0) | **OVERLAY RULE — React-gated, always-on, advisory** | `ui-design-system.md` (foundations) + `ui-components.md` + `ui-layout-and-motion.md` / `ux-patterns.md` + `ux-dashboard-patterns.md` / `mobile-design-guidelines.md` (React `overlay_rules`); install into `.claude/rules/` only when React is selected, then load every session. The authoritative source for `design-system-compliance.md`'s thin pointer and `react-patterns.md`'s trimmed a11y cross-ref; consumed by the `ui-ux-design` / `component-design` skills + `ui-designer` agent | when React selected (advisory rule) |
 
 The two that reach *enforced* (claim-audit, eval/HITL) do so the same way P0-2 did — by strengthening
 an **existing** gate's owner-agent checklist, not by minting a token. Everything else is advisory by

claude_code_kit-0.56.0/docs/cursor-export.md

@@ -0,0 +1,94 @@
+# Exporting to Cursor / VS Code / GitHub Copilot
+
+claude-kit's home is **Claude Code**, where it installs a `.claude/` configuration and runs a gated,
+multi-agent `/sdlc` pipeline. A teammate working in **Cursor**, **VS Code**, or **GitHub Copilot**
+uses that editor's *own* single agent — which can't read `.claude/` or run the pipeline. `claude-kit
+export` bridges the gap by projecting the **same resolved plan** into the formats those agents read
+natively.
+
+It is a **projection**, not a second source of truth: the exporter re-targets the exact `ResolvedPlan`
+that `init` installs (`catalog.resolve()` is untouched, no new stack knowledge). Re-run it any time to
+regenerate; it writes **configuration only** — no application code, no Docker.
+
+## Usage
+
+```bash
+claude-kit export .                                   # default target: cursor
+claude-kit export . -t cursor -t agents -t copilot    # all three
+claude-kit export . --dry-run                         # preview; write nothing
+claude-kit export . --force                            # refresh existing files in place
+claude-kit export . -t agents --json                  # machine-readable file list
+```
+
+By default `export` resolves from the project's **installed selection**
+(`.claude/config/init-options.json`), so the export matches what was scaffolded. Pass `--config FILE`
+or `--defaults` to resolve a fresh selection instead — useful for a standalone export into a project
+that never ran `init`.
+
+**Conflict-safe writes.** Exports are regenerable, so `--force` refreshes them in place. Without
+`--force`, an existing (possibly hand-edited) file is preserved and the new version is written beside it
+as a `<name>.claude-kit` sidecar — the same non-destructive convention the installer uses.
+
+## What each target emits
+
+| Target | Files | Contents |
+|---|---|---|
+| `cursor` | `.cursor/rules/000-project.mdc` | The project **charter** + single-agent SDLC workflow + fidelity note. `alwaysApply: true` — always in context. |
+| | `.cursor/rules/<rule>.mdc` (one per rule) | Every core rule and every stack overlay, `alwaysApply: false` (agent pulls on demand by `description`); overlays also carry `globs` to auto-attach on matching files. |
+| | `.cursor/mcp.json` | Your selected MCP servers (omitted when none are selected). |
+| `agents` | `AGENTS.md` (repo root) | Charter + workflow + a **rule index** (one line per rule) + the fidelity note. Read by both Cursor and Copilot. |
+| `copilot` | `.github/copilot-instructions.md` | The same synthesized document as `agents`. |
+
+## `.mdc` frontmatter derivation
+
+Each Cursor rule file gets YAML frontmatter derived generically from the rule's own content — no
+per-stack branching:
+
+- **`description`** — the rule's H1 heading plus its first lead sentence (falling back to a humanized
+  filename), trimmed to ~200 characters. Cursor uses this to decide when to pull an on-demand rule.
+- **`alwaysApply`** — `false` for the whole rule set (mirroring Claude Code's on-demand rule loading);
+  `true` only for the synthesized `000-project.mdc` charter.
+- **`globs`** — attached to **overlay** rules only, chosen from the overlay's lane and the plan's
+  *language/database* values (not framework names):
+
+  | Lane | Source value | Example glob |
+  |---|---|---|
+  | frontend | `frontend_language` | `typescript` → `**/*.ts,**/*.tsx` |
+  | backend | `backend_language` | `python` → `**/*.py`, `go` → `**/*.go` |
+  | database | `database` | `postgres` → `**/*.sql` |
+
+  A store with no reliable file signal (e.g. a document database) gets **no** glob and loads by
+  `description` instead. Core rules never get globs.
+
+Values are JSON-quoted so the frontmatter is always valid YAML — an unquoted glob such as
+`**/*.{ts,tsx}` would be misparsed as a YAML flow mapping.
+
+## MCP projection
+
+Cursor's `.cursor/mcp.json` uses a top-level `mcpServers` map and infers transport from the keys
+present — stdio servers use `command`/`args`/`env`, remote servers use `url`/`headers`. claude-kit's
+internal `type` discriminator is **dropped**; every other key passes through verbatim.
+
+## Fidelity: what ports, and what doesn't
+
+| Capability | Claude Code | Exported (Cursor / AGENTS.md / Copilot) |
+|---|---|---|
+| Engineering rules + stack/design-system overlays | ✅ enforced/on-demand | ✅ full text (`.mdc`) or index (AGENTS.md) |
+| Project charter (stack, commands, lanes) | ✅ | ✅ |
+| MCP servers | ✅ (`.mcp.json`) | ✅ Cursor (`.cursor/mcp.json`); not applicable to AGENTS.md/Copilot |
+| SDLC phases | ✅ **enforced quality gates** | ⚠️ single-agent **self-check checklist** (guidance) |
+| Independent reviewer subagents | ✅ separate agents | ❌ one agent plays every role |
+| Security scan (parallel sub-scanners) | ✅ | ⚠️ a security self-check step in the checklist |
+| Automated defect loop (blocks on unproven verdict) | ✅ | ⚠️ described as discipline; nothing blocks |
+
+The enforced gates, reviewer subagents, and automated defect loop depend on Claude Code's multi-agent
+runtime and **cannot** be reproduced under a single-agent editor. The export is honest about this: the
+charter carries a "What ports from Claude Code — and what doesn't" note, and the workflow guide opens
+by stating it is a self-check checklist, not enforced gates.
+
+## Out of scope (for now)
+
+- **Cursor hooks** (`.cursor/hooks.json`) and **commands/skills** export — a different event/format
+  model; noted as future work.
+- **Drift tracking** of exported files in the `init-options.json` ownership manifest — exports are
+  regenerable projections (`export --force` refreshes), so they are intentionally not tracked.

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "claude-code-kit"
-version = "0.54.0"
+version = "0.56.0"
 description = "Cookiecutter-style scaffolder for an autonomous Claude Code SDLC configuration (no app code, no Docker). Asks ordered questions and installs CLAUDE.md + .claude/ (rules, the chosen profile's agents/skills, hooks, artifact templates) + optional .mcp.json; run /sdlc to drive spec → review → build → test → security → ship through profile-aware quality gates, working memory, and a self-improving learnings loop."
 readme = "README.md"
 requires-python = ">=3.9"

claude_code_kit-0.56.0/scripts/check_rule_sizes.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Fail if any shipped rule file is close to Claude Code's memory/rule-file size limit.
+
+Claude Code warns (and can load a rule only partially) when a memory/rule file exceeds
+**40,000 characters**. Every rule this kit ships is copied verbatim into a user project's
+``.claude/rules/`` and loaded on demand, so an over-limit rule silently degrades in every install.
+
+This is an offline, deterministic CI gate. It scans the rule files the kit distributes — the
+stack-agnostic core (``rules/``), the per-stack overlays (``templates/stacks/**/rules/``), and the
+org overlays (``templates/org/rules/``) — and fails if any is at or above ``THRESHOLD`` characters.
+The threshold sits below the hard limit to keep headroom for small edits before a file must be split.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# Claude Code's hard limit is 40,000 characters; keep 2k of headroom so a small edit does not
+# immediately push a rule over the line before someone notices it needs splitting.
+HARD_LIMIT = 40_000
+THRESHOLD = 38_000
+
+# Glob patterns (relative to ROOT) for every rule file the kit ships into a user's .claude/rules/.
+RULE_GLOBS = (
+    "rules/*.md",
+    "templates/stacks/**/rules/*.md",
+    "templates/org/rules/*.md",
+)
+
+
+def rule_files(root: Path | None = None) -> list[Path]:
+    """Return every shipped rule file, de-duplicated and sorted by path."""
+    base = root or ROOT
+    found: set[Path] = set()
+    for pattern in RULE_GLOBS:
+        found.update(base.glob(pattern))
+    return sorted(found)
+
+
+def oversized(
+    root: Path | None = None, threshold: int = THRESHOLD
+) -> list[tuple[Path, int]]:
+    """Return ``(path, char_count)`` for each rule file at or above ``threshold`` characters."""
+    base = root or ROOT
+    out: list[tuple[Path, int]] = []
+    for path in rule_files(base):
+        count = len(path.read_text(encoding="utf-8"))
+        if count >= threshold:
+            out.append((path.relative_to(base), count))
+    return out
+
+
+def main() -> int:
+    files = rule_files()
+    bad = oversized()
+    if bad:
+        print(
+            f"FAIL  rule file(s) at/over {THRESHOLD:,} chars "
+            f"(Claude Code's limit is {HARD_LIMIT:,}); split them by concern:"
+        )
+        for rel, count in bad:
+            print(f"  - {rel} -> {count:,} chars")
+        return 1
+    print(
+        f"OK    all {len(files)} shipped rule file(s) are under {THRESHOLD:,} chars "
+        f"(limit {HARD_LIMIT:,})"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/skills/component-design/SKILL.md

@@ -9,7 +9,7 @@ Design and implement the component: $ARGUMENTS.
 
 ## Steps
 
-1. **Read the design system**: Read `.claude/rules/ui-design-system.md` (installed as a React overlay rule) for visual rules and component standards — or a project's `docs/references/ui/ui-design-system.md` equivalent. Read whichever is present.
+1. **Read the design system**: Read `.claude/rules/ui-design-system.md` (foundations & index) and `.claude/rules/ui-components.md` (component standards — cards, badges, buttons, form controls, compound components), both installed as React overlay rules — or a project's `docs/references/ui/ui-design-system.md` equivalent. Read whichever is present.
 
 2. **Check existing components**: Check the project's component directory for available UI primitives and established patterns. Search for similar components to follow the project's conventions.
 
@@ -95,8 +95,8 @@ Design and implement the component: $ARGUMENTS.
 ## References
 
 - UI primitives: Project's UI primitives directory/barrel export
-- Design system: `.claude/rules/ui-design-system.md` (React overlay) or `docs/references/ui/ui-design-system.md` (if present)
-- UX patterns: `.claude/rules/ux-patterns.md` (React overlay) or `docs/references/ui/ux-patterns.md` (if present)
+- Design system: `.claude/rules/ui-design-system.md` (foundations) + `.claude/rules/ui-components.md` + `.claude/rules/ui-layout-and-motion.md` (React overlay) or `docs/references/ui/ui-design-system.md` (if present)
+- UX patterns: `.claude/rules/ux-patterns.md` + `.claude/rules/ux-dashboard-patterns.md` (React overlay) or `docs/references/ui/ux-patterns.md` (if present)
 - Rules: `.claude/rules/frontend-best-practices.md`, `.claude/rules/responsive-and-accessibility.md`
 
 ## Examples

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/skills/ui-ux-design/SKILL.md

@@ -9,9 +9,9 @@ Verify UI/UX design compliance for $ARGUMENTS.
 
 ## Steps
 
-1. **Read the design system**: Read `.claude/rules/ui-design-system.md` to load the full design rules — colors, typography, spacing, cards, icons, badges, components, and accessibility. (Installed as an overlay rule when the React stack is selected.) This file is **authoritative**: if the quick-check table below ever conflicts with it, follow the rule file.
+1. **Read the design system**: Read `.claude/rules/ui-design-system.md` (foundations & index — colors, typography, spacing, icons, tokens) and its companions `.claude/rules/ui-components.md` (cards, badges, buttons, form controls, states, compound components) and `.claude/rules/ui-layout-and-motion.md` (page layout, motion, accessibility, page blueprints). (Installed as overlay rules when the React stack is selected.) These files are **authoritative**: if the quick-check table below ever conflicts with them, follow the rule files.
 
-2. **Read the UX patterns doc**: Read `.claude/rules/ux-patterns.md` for status expression rules, empty state guidelines, breadcrumb conventions, page blueprints, and data color rules. For responsive/native specifics, also read `.claude/rules/mobile-design-guidelines.md`.
+2. **Read the UX patterns docs**: Read `.claude/rules/ux-patterns.md` for status expression rules, empty state guidelines, breadcrumb conventions, page blueprint selection, and data color rules, and `.claude/rules/ux-dashboard-patterns.md` for chart standards, tab-bar limits, KPI-grid layouts, and the global filter strip. For responsive/native specifics, also read `.claude/rules/mobile-design-guidelines.md`.
 
 3. **Identify the page archetype**: Determine if the target is a **List**, **Dashboard**, **Detail**, or **Config** page. Each archetype has specific compound components and hooks it should use.
 
@@ -64,8 +64,8 @@ Verify UI/UX design compliance for $ARGUMENTS.
 
 ## References
 
-- Design system: `.claude/rules/ui-design-system.md`
-- UX patterns: `.claude/rules/ux-patterns.md`
+- Design system: `.claude/rules/ui-design-system.md` (foundations), `.claude/rules/ui-components.md`, `.claude/rules/ui-layout-and-motion.md`
+- UX patterns: `.claude/rules/ux-patterns.md`, `.claude/rules/ux-dashboard-patterns.md`
 - Mobile / responsive: `.claude/rules/mobile-design-guidelines.md`
 - Sidebar navigation: `docs/references/ui/sidebar-navigation.md` (project-specific, if present)
 - UI components: `src/components/ui/index.ts`

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/src/claude_kit/__init__.py

@@ -7,4 +7,4 @@ Docker): ``claude-kit init`` asks ordered questions and lays down ``CLAUDE.md``
 as a plugin. Extensibility is data-driven via the ``catalog/`` (stacks, profiles, MCP).
 """
 
-__version__ = "0.54.0"
+__version__ = "0.56.0"

{claude_code_kit-0.54.0 → claude_code_kit-0.56.0}/src/claude_kit/cli.py

@@ -27,7 +27,8 @@ from claude_kit import (
     upgrader,
     validator,
 )
-from claude_kit.models import ResolvedPlan
+from claude_kit import export as exporter
+from claude_kit.models import ResolvedPlan, Selection
 
 # Planned-but-unimplemented commands are hidden from `--help` by default so they
 # can't be mistaken for working features. Set CLAUDE_KIT_EXPERIMENTAL=1 to surface
@@ -316,6 +317,110 @@ def init(
         )
 
 
+def _plan_for_export(
+    src: Path, target_dir: Path, *, config: Optional[str], defaults: bool
+) -> ResolvedPlan:
+    """Resolve the plan to export: prefer the project's installed selection, else config/defaults/prompt.
+
+    ``export .`` in an installed project reads ``.claude/config/init-options.json`` so the export
+    matches what was scaffolded. ``--config`` / ``--defaults`` force a fresh resolution (useful for a
+    standalone export into a project that never ran ``init``); with neither and no install present, it
+    falls back to the interactive prompt via :func:`_resolve_plan`.
+    """
+    opts = target_dir / ".claude" / "config" / "init-options.json"
+    if config is None and not defaults and opts.is_file():
+        try:
+            data = json.loads(opts.read_text(encoding="utf-8"))
+            selection = Selection.from_dict(data.get("selection", {}))
+            return catalog.resolve(src, selection)
+        except (ValueError, KeyError, json.JSONDecodeError) as exc:
+            typer.echo(f"error: could not read installed selection: {exc}", err=True)
+            raise typer.Exit(2) from exc
+    return _resolve_plan(src, config=config, defaults=defaults)
+
+
+# Module-level singleton: a repeatable-list option can't be defined inline (ruff B008 flags a call in
+# a mutable-typed argument default), so the Option lives here and the command reads it as its default.
+_EXPORT_TARGET_OPTION = typer.Option(
+    None,
+    "--target",
+    "-t",
+    help="export target(s), repeatable: cursor | agents | copilot (default: cursor)",
+)
+
+
+@app.command()
+def export(
+    path: str = typer.Argument(".", help="target project dir (default: .)"),
+    target: Optional[list[str]] = _EXPORT_TARGET_OPTION,
+    config: Optional[str] = typer.Option(
+        None,
+        "--config",
+        help="resolve the selection from a YAML file instead of the installed one",
+    ),
+    defaults: bool = typer.Option(
+        False,
+        "--defaults",
+        help="resolve from catalog defaults instead of the installed selection",
+    ),
+    force: bool = typer.Option(
+        False,
+        "--force",
+        help="overwrite existing exported files instead of writing .claude-kit sidecars",
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="report the files that would be written; write nothing"
+    ),
+    json_out: bool = typer.Option(
+        False, "--json", help="emit the written-file list as JSON instead of text"
+    ),
+) -> None:
+    """Export the config for Cursor / AGENTS.md / GitHub Copilot (editors that aren't Claude Code).
+
+    Projects the same resolved plan claude-kit installs under .claude/ into the formats a single-agent
+    editor reads natively — the full rule set + a project charter + the SDLC workflow as guidance, plus
+    MCP servers for Cursor. The enforced gates and reviewer subagents are Claude Code-only.
+    """
+    targets = list(dict.fromkeys(target or ["cursor"]))
+    unknown = [t for t in targets if t not in exporter.VALID_TARGETS]
+    if unknown:
+        typer.echo(
+            f"error: unknown export target(s): {', '.join(unknown)} "
+            f"(choices: {', '.join(exporter.VALID_TARGETS)})",
+            err=True,
+        )
+        raise typer.Exit(2)
+    with ExitStack() as stack:
+        src = scaffold.payload_dir(stack)
+        target_dir = Path(path).expanduser().resolve()
+        plan = _plan_for_export(src, target_dir, config=config, defaults=defaults)
+        written = exporter.export_targets(
+            src, target_dir, plan, targets, force=force, dry_run=dry_run
+        )
+
+    if json_out:
+        typer.echo(
+            json.dumps(
+                {
+                    "target": str(target_dir),
+                    "targets": targets,
+                    "dry_run": dry_run,
+                    "written": written,
+                },
+                indent=2,
+            )
+        )
+        return
+
+    typer.echo(f"\nclaude-kit export → {', '.join(targets)}  ({target_dir})\n")
+    for w in written:
+        typer.echo(f"  {'+' if dry_run else '•'} {w}")
+    tail = "  (dry run — nothing written)" if dry_run else ""
+    typer.echo(
+        f"\n{'Would write' if dry_run else 'Wrote'} {len(written)} file(s).{tail}"
+    )
+
+
 @app.command()
 def validate(
     path: str = typer.Argument(".", help="target project dir (default: .)"),