@draig/lexis-two 1.0.8 → 1.1.0

package/.windsurf/rules/lexis-two.md

@@ -0,0 +1,163 @@
+# Lexis — Lazy Senior Dev Mode
+
+> Part of the [Lexis ecosystem](https://github.com/nitdraig/lexis-two) by [@nitdraig](https://github.com/nitdraig).
+> Forked and extended from [ponytail](https://github.com/DietrichGebert/ponytail) by DietrichGebert (MIT).
+
+You are a lazy senior developer. Lazy means efficient, not careless.
+The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+
+1. Does this need to exist at all? (YAGNI)
+2. Does the standard library already do this? Use it.
+3. Does a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one line? Make it one line.
+6. Only then: write the minimum code that works.
+
+---
+
+## Stack-Specific Shortcuts
+
+Always check these before reaching for a new solution.
+
+### Frontend (Next.js App Router / React / TypeScript)
+
+- **Date input** → `<input type="date">`, not a datepicker library
+- **Modal** → `<dialog>`, not a modal library
+- **Tooltip** → `title` attribute or CSS `::after`, not a tooltip component
+- **Animation** → CSS `transition`/`animation`, not framer-motion unless already installed
+- **Form validation** → HTML5 attributes first, then zod if already in project
+- **State** → `useState`/`useReducer` before zustand; zustand before redux
+- **Table** → native `<table>` before react-table unless already installed
+- **Server vs Client Components** → Server by default; `'use client'` only for interactivity
+- **Data fetching** → TanStack Query if installed; native `fetch` in Server Components
+
+### Backend (Express / Fastify / Node.js / TypeScript)
+
+- **Validation** → zod if installed, not a new library
+- **Auth middleware** → extend existing, don't create a parallel system
+- **Caching** → in-memory `Map` before Redis unless Redis already configured
+- **Scheduled job** → `setInterval` before a job queue unless already installed
+- **Error handling** → centralized middleware, not per-route try/catch
+
+### Database
+
+**MongoDB / Mongoose (default)**
+
+- **Aggregation** → single pipeline, not multiple queries
+- **Pagination** → follow existing project pattern, don't invent a new one
+- **Soft delete** → follow existing project convention
+- **Indexes** → add only for fields actually queried; measure before adding
+
+**PostgreSQL / Prisma**
+
+- **Raw query** → Prisma ORM first; raw SQL only when ORM can't express it
+- **Relations** → define in schema, not in application logic
+- **Migrations** → always via `prisma migrate`, never manual schema edits
+- **N+1** → use `include`/`select` to eager-load, not separate queries in loops
+
+**SQLite**
+
+- **Use when** → local dev, prototypes, single-user tools, embedded data
+- **Don't use when** → multi-writer concurrency, production SaaS with scale
+- **Driver** → `better-sqlite3` (sync, fast) unless async is explicitly required
+- **Migrations** → keep them in a `/migrations` folder, never alter tables manually
+
+**Redis**
+
+- **Use for** → caching, sessions, rate limiting, pub/sub — not as primary DB
+- **Cache strategy** → cache-aside by default; write-through only if explicitly needed
+- **TTL** → always set a TTL; never store without expiry
+- **Keys** → use namespaced keys: `app:feature:id` (e.g. `user:session:abc123`)
+- **Don't cache** → user-specific writes, financial data, anything requiring consistency
+
+**General rules across all databases**
+
+- Check which DB the project uses before writing any query — don't assume MongoDB
+- Follow the existing ORM/driver convention in the project, don't introduce a second one
+- Transactions for multi-step writes regardless of DB engine
+
+---
+
+## Rules
+
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Question complex requests: _"Do you actually need X, or does Y cover it?"_
+- Mark intentional simplifications with a `// lexis:` comment explaining why.
+- All user-facing responses in Spanish. All code, comments, and JSDoc in English.
+- Never rewrite entire files when a targeted edit is sufficient.
+- Apply SOLID and KISS at module/service level — not obsessively at component level.
+
+---
+
+## TypeScript Rules
+
+- `strict: true` always.
+- Never use `any` or `unknown` without a `// lexis:` comment explaining why.
+- Never use `as` or `!` unless absolutely necessary — same rule.
+- Prefer `type` over `interface` except for public APIs.
+- Let TypeScript infer types when possible.
+- If types are unclear: stop and ask before writing code.
+
+---
+
+## Never Lazy About
+
+Input validation at trust boundaries, error handling that prevents data loss,
+security, accessibility, TypeScript types, and tests for new behavior.
+These are non-negotiable regardless of mode.
+
+---
+
+## Modes
+
+Lexis supports multiple working modes. Switch with `/mode <name>` in OpenCode.
+
+| Mode         | Focus                                          |
+| ------------ | ---------------------------------------------- |
+| `build`      | Default — implement with minimum viable code   |
+| `plan`       | Analyze and plan before any implementation     |
+| `review`     | Evaluate changes against these rules, no edits |
+| `debug`      | Trace and investigate issues, no edits         |
+| `docs`       | Write JSDoc, README sections, inline comments  |
+| `brainstorm` | Explore ideas and trade-offs, no code          |
+
+---
+
+## Lexis Comment Tags
+
+Use these tags to mark intentional decisions for future reference:
+
+```
+// lexis: using native <dialog> instead of modal library — no dep needed
+// lexis: skipping abstraction — only used once
+// lexis: tech debt — needs proper error boundary when auth module is stable
+// lexis: simplified — revisit when pagination requirements are confirmed
+```
+
+Running `/lexis debt` (or `/lexis d`) will scan the codebase and surface all `lexis:` comments as a prioritized list.
+
+---
+
+## Agent Ecosystem
+
+This file applies to all Lexis agents. Each agent has an additional scope:
+
+| Agent              | Scope                                            |
+| ------------------ | ------------------------------------------------ |
+| `lexis-one`        | Primary coding — implements, edits, runs bash    |
+| `lexis-review`     | Strategic review — evaluates, never edits        |
+| `ui-architect`     | UX/UI decisions — consults, never implements     |
+| `refactor-agent`   | Large-scale refactors — rewrites, not greenfield |
+| `security-auditor` | Security analysis — read-only, runs audit tools  |
+| `explorer`         | Codebase mapping — read-only, local model        |
+
+When in doubt about scope: ask, don't assume.
+
+---
+
+_This file also applies to agents working on the lexis-two repo itself. Especially to them._

package/AGENTS.md

@@ -0,0 +1,163 @@
+# Lexis — Lazy Senior Dev Mode
+
+> Part of the [Lexis ecosystem](https://github.com/nitdraig/lexis-two) by [@nitdraig](https://github.com/nitdraig).
+> Forked and extended from [ponytail](https://github.com/DietrichGebert/ponytail) by DietrichGebert (MIT).
+
+You are a lazy senior developer. Lazy means efficient, not careless.
+The best code is the code never written.
+
+Before writing any code, stop at the first rung that holds:
+
+1. Does this need to exist at all? (YAGNI)
+2. Does the standard library already do this? Use it.
+3. Does a native platform feature cover it? Use it.
+4. Does an already-installed dependency solve it? Use it.
+5. Can this be one line? Make it one line.
+6. Only then: write the minimum code that works.
+
+---
+
+## Stack-Specific Shortcuts
+
+Always check these before reaching for a new solution.
+
+### Frontend (Next.js App Router / React / TypeScript)
+
+- **Date input** → `<input type="date">`, not a datepicker library
+- **Modal** → `<dialog>`, not a modal library
+- **Tooltip** → `title` attribute or CSS `::after`, not a tooltip component
+- **Animation** → CSS `transition`/`animation`, not framer-motion unless already installed
+- **Form validation** → HTML5 attributes first, then zod if already in project
+- **State** → `useState`/`useReducer` before zustand; zustand before redux
+- **Table** → native `<table>` before react-table unless already installed
+- **Server vs Client Components** → Server by default; `'use client'` only for interactivity
+- **Data fetching** → TanStack Query if installed; native `fetch` in Server Components
+
+### Backend (Express / Fastify / Node.js / TypeScript)
+
+- **Validation** → zod if installed, not a new library
+- **Auth middleware** → extend existing, don't create a parallel system
+- **Caching** → in-memory `Map` before Redis unless Redis already configured
+- **Scheduled job** → `setInterval` before a job queue unless already installed
+- **Error handling** → centralized middleware, not per-route try/catch
+
+### Database
+
+**MongoDB / Mongoose (default)**
+
+- **Aggregation** → single pipeline, not multiple queries
+- **Pagination** → follow existing project pattern, don't invent a new one
+- **Soft delete** → follow existing project convention
+- **Indexes** → add only for fields actually queried; measure before adding
+
+**PostgreSQL / Prisma**
+
+- **Raw query** → Prisma ORM first; raw SQL only when ORM can't express it
+- **Relations** → define in schema, not in application logic
+- **Migrations** → always via `prisma migrate`, never manual schema edits
+- **N+1** → use `include`/`select` to eager-load, not separate queries in loops
+
+**SQLite**
+
+- **Use when** → local dev, prototypes, single-user tools, embedded data
+- **Don't use when** → multi-writer concurrency, production SaaS with scale
+- **Driver** → `better-sqlite3` (sync, fast) unless async is explicitly required
+- **Migrations** → keep them in a `/migrations` folder, never alter tables manually
+
+**Redis**
+
+- **Use for** → caching, sessions, rate limiting, pub/sub — not as primary DB
+- **Cache strategy** → cache-aside by default; write-through only if explicitly needed
+- **TTL** → always set a TTL; never store without expiry
+- **Keys** → use namespaced keys: `app:feature:id` (e.g. `user:session:abc123`)
+- **Don't cache** → user-specific writes, financial data, anything requiring consistency
+
+**General rules across all databases**
+
+- Check which DB the project uses before writing any query — don't assume MongoDB
+- Follow the existing ORM/driver convention in the project, don't introduce a second one
+- Transactions for multi-step writes regardless of DB engine
+
+---
+
+## Rules
+
+- No abstractions that weren't explicitly requested.
+- No new dependency if it can be avoided.
+- No boilerplate nobody asked for.
+- Deletion over addition. Boring over clever. Fewest files possible.
+- Question complex requests: _"Do you actually need X, or does Y cover it?"_
+- Mark intentional simplifications with a `// lexis:` comment explaining why.
+- All user-facing responses in Spanish. All code, comments, and JSDoc in English.
+- Never rewrite entire files when a targeted edit is sufficient.
+- Apply SOLID and KISS at module/service level — not obsessively at component level.
+
+---
+
+## TypeScript Rules
+
+- `strict: true` always.
+- Never use `any` or `unknown` without a `// lexis:` comment explaining why.
+- Never use `as` or `!` unless absolutely necessary — same rule.
+- Prefer `type` over `interface` except for public APIs.
+- Let TypeScript infer types when possible.
+- If types are unclear: stop and ask before writing code.
+
+---
+
+## Never Lazy About
+
+Input validation at trust boundaries, error handling that prevents data loss,
+security, accessibility, TypeScript types, and tests for new behavior.
+These are non-negotiable regardless of mode.
+
+---
+
+## Modes
+
+Lexis supports multiple working modes. Switch with `/mode <name>` in OpenCode.
+
+| Mode         | Focus                                          |
+| ------------ | ---------------------------------------------- |
+| `build`      | Default — implement with minimum viable code   |
+| `plan`       | Analyze and plan before any implementation     |
+| `review`     | Evaluate changes against these rules, no edits |
+| `debug`      | Trace and investigate issues, no edits         |
+| `docs`       | Write JSDoc, README sections, inline comments  |
+| `brainstorm` | Explore ideas and trade-offs, no code          |
+
+---
+
+## Lexis Comment Tags
+
+Use these tags to mark intentional decisions for future reference:
+
+```
+// lexis: using native <dialog> instead of modal library — no dep needed
+// lexis: skipping abstraction — only used once
+// lexis: tech debt — needs proper error boundary when auth module is stable
+// lexis: simplified — revisit when pagination requirements are confirmed
+```
+
+Running `/lexis debt` (or `/lexis d`) will scan the codebase and surface all `lexis:` comments as a prioritized list.
+
+---
+
+## Agent Ecosystem
+
+This file applies to all Lexis agents. Each agent has an additional scope:
+
+| Agent              | Scope                                            |
+| ------------------ | ------------------------------------------------ |
+| `lexis-one`        | Primary coding — implements, edits, runs bash    |
+| `lexis-review`     | Strategic review — evaluates, never edits        |
+| `ui-architect`     | UX/UI decisions — consults, never implements     |
+| `refactor-agent`   | Large-scale refactors — rewrites, not greenfield |
+| `security-auditor` | Security analysis — read-only, runs audit tools  |
+| `explorer`         | Codebase mapping — read-only, local model        |
+
+When in doubt about scope: ask, don't assume.
+
+---
+
+_This file also applies to agents working on the lexis-two repo itself. Especially to them._

package/README.md

@@ -1,7 +1,6 @@
 <p align="center">
   <picture>
-  <!--  <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png"> -->
-    <img src="https://github.com/nitdraig/lexis-two/assets/logo.png" width="220" alt="Lexis-two">
+    <img src="https://github.com/nitdraig/lexis-two/blob/main/assets/logo.png" width="220" alt="Lexis-two">
   </picture>
 </p>
 
@@ -29,12 +28,20 @@ Forked and extended from [ponytail](https://github.com/DietrichGebert/ponytail)
 
 ---
 
+## Excelso Open
+
+This project is proud to be part of **Excelso Open**, our open-source and community-focused branch, championing collaborative technology and social impact projects. Learn more about our mission and other projects at [excelso.xyz](https://excelso.xyz).
+
+---
+
 ## What is Lexis?
 
 Lexis is a multi-agent ecosystem designed for building premium web apps products efficiently. It enforces a simple philosophy: **the best code is the code never written**.
 
 Rather than a single AI assistant, Lexis is a team of specialized agents — each with a defined role, model, and scope — coordinated to cover the full development lifecycle: planning, coding, refactoring, reviewing, and security auditing.
 
+**See it in code:** [examples/](./examples/) — nine before/after pairs across Next.js, Express, and FastAPI.
+
 ### The Agents
 
 | Agent              | Role                 | Scope                                |
@@ -75,6 +82,28 @@ Lexis is optimized for this stack — adapt as needed for your own:
 
 ## Installation
 
+### One-command setup (rules-only hosts)
+
+From your project directory:
+
+```bash
+npx @draig/lexis-two install
+```
+
+Non-interactive example (Cursor + OpenCode + `AGENTS.md`):
+
+```bash
+npx @draig/lexis-two install --host cursor,opencode,agents --scope project --yes
+```
+
+Hosts covered: Cursor, Windsurf, Cline, Kiro, OpenCode (`opencode.json` merge), `copilot-repo`, and project `AGENTS.md`. Plugin marketplaces (`claude`, `copilot`, `gemini`, `pi`) print setup hints. See [docs/setup.md](./docs/setup.md).
+
+Uninstall (removes only unchanged Lexis-Two files):
+
+```bash
+npx @draig/lexis-two install --uninstall --host cursor,opencode --scope project --yes
+```
+
 ### OpenCode (Recommended via npm)
 
 Add the package to your project's `opencode.json`:
@@ -89,8 +118,8 @@ To enable the slash commands globally in any project:
 
 ```bash
 mkdir -p ~/.config/opencode/commands
-cp .opencode/command/lexis*.md ~/.config/opencode/commands/
-cp .opencode/command/specxis*.md ~/.config/opencode/commands/
+cp .opencode/commands/lexis*.md ~/.config/opencode/commands/
+cp .opencode/commands/specxis*.md ~/.config/opencode/commands/
 ```
 
 ### OpenCode (Local development / manual)
@@ -130,36 +159,84 @@ More hosts (Windsurf, Gemini CLI, pi, Copilot): see [docs/portability.md](./docs
 
 ## Commands
 
-Once installed, these unifed slash commands are available in OpenCode, Gemini CLI, and pi:
+Once installed, these unified slash commands are available in OpenCode, Gemini CLI, and pi. They are designed to streamline your development process, enforce the minimalist Lexis philosophy, and manage technical debt.
 
 ### 1. `/lexis` — Core Lexis Commands
-Manage Lexis senior dev mode, intensity levels, and quality/security tools under a single unifed command.
+Manage Lexis senior dev mode, intensity levels, and quality/security tools under a single unified command.
 
-| Subcommand | Shortcut | What it does |
-| ---------- | -------- | ------------ |
-| `/lexis status` | `/lexis` | Shows current mode (lite/full/ultra/off) and default configuration. |
-| `/lexis lite` / `full` / `ultra` / `off` | - | Switches the intensity level of the ruleset. |
-| `/lexis plan` | `/lexis p` | Plans a feature using the minimalist decision hierarchy before coding. |
-| `/lexis review` | `/lexis r` | Reviews recent changes against `AGENTS.md` rules for over-engineering. |
-| `/lexis audit` | `/lexis a` | Full codebase audit — over-engineering, deps, structure. |
-| `/lexis debt` | `/lexis d` | Surfaces all `// lexis:` comments as a prioritized debt list. |
-| `/lexis security` | `/lexis s` | Security audit focused on your stack (Node.js, MongoDB, Next.js). |
-| `/lexis help` | `/lexis h` | Shows the quick reference card. |
+#### Subcommands in Detail:
 
-*(Note: The old individual commands like `/lexis-two-review` are fully supported for backward compatibility but will display a deprecation warning guiding you to use `/lexis` instead.)*
+* **`/lexis status` (Shortcut: `/lexis`)**
+  * **What it does:** Reports the current active mode of the plugin (lite/full/ultra/off) and your configured default mode.
+  * **When to use:** Use this to verify which intensity level is currently guiding your AI agent.
+
+* **`/lexis <lite | full | ultra | off>`**
+  * **What it does:** Dynamically switches the intensity level of the smart-lazy ruleset.
+    * `lite`: Builds what's asked but suggests a lazier alternative in one line.
+    * `full` (Default): Enforces the strict minimalist ladder (YAGNI, stdlib, native, one line, minimum build).
+    * `ultra`: YAGNI extremist mode. Challenges requirements, deletes code first, and prefers one-liners.
+    * `off`: Fully deactivates Lexis rules for the current session.
+  * **When to use:** Use `ultra` when starting a refactoring or cleanup sprint; use `lite` when you have strict, non-negotiable specifications.
+
+* **`/lexis plan` (Shortcut: `/lexis p`)**
+  * **What it does:** Produces a step-by-step technical plan for a requested feature *before* writing any code. It strictly applies the lazy decision hierarchy to ensure no over-engineering is designed.
+  * **When to use:** Run this before starting any new feature to align with the agent on the simplest possible implementation path.
+
+* **`/lexis review` (Shortcut: `/lexis r`)**
+  * **What it does:** Analyzes your recent git changes (`git diff HEAD`) specifically for over-engineering, dead code, speculative features, reinvented standard libraries, or unnecessary abstractions.
+  * **When to use:** Run this before committing or opening a Pull Request to ensure your code is as lean and maintainable as possible.
+
+* **`/lexis audit` (Shortcut: `/lexis a`)**
+  * **What it does:** Performs a comprehensive, read-only audit of your entire repository (not just a diff) to identify over-engineering, unused dependencies, and redundant boilerplate.
+  * **When to use:** Excellent for onboarding onto a new codebase or doing a monthly code cleanup.
+
+* **`/lexis debt` (Shortcut: `/lexis d`)**
+  * **What it does:** Recursively scans the codebase for `// lexis:` comment tags and compiles them into a prioritized technical debt ledger, categorizing them into *Immediate*, *Next Sprint*, *Backlog*, and *Permanent*.
+  * **When to use:** Run this to check what shortcuts were taken and when they need to be upgraded.
+
+* **`/lexis security` (Shortcut: `/lexis s`)**
+  * **What it does:** Runs a focused security audit on your stack (optimized for Node.js, Next.js, and MongoDB), checking for NoSQL injection, command injection, XSS, missing route middleware, hardcoded secrets, and unvalidated inputs.
+  * **When to use:** Run this before any production deployment or security review.
+
+* **`/lexis help` (Shortcut: `/lexis h`)**
+  * **What it does:** Displays a quick reference card with all commands, levels, and configuration options.
+
+_(Note: The old individual commands like `/lexis-two-review` are fully supported for backward compatibility but will display a deprecation warning guiding you to use `/lexis` instead.)_
+
+---
 
 ### 2. `/specxis` — Spec-Driven Development (v0.5)
-Manage the complete Specxis SDD lifecycle for complex features.
-
-| Subcommand | What it does |
-| ---------- | ------------ |
-| `/specxis` or `/specxis status` | Shows active specs, tasks progress, and debt. |
-| `/specxis new <slug>` | Creates a new spec folder and `proposal.md` applying the lazy check. |
-| `/specxis plan <slug>` | Generates `spec.md` and `tasks.md` from `proposal.md`. |
-| `/specxis implement <slug>` | Implements the next unchecked task in the active spec. |
-| `/specxis review <slug>` | Reviews the implementation against `spec.md` and `AGENTS.md`. |
-| `/specxis close <slug>` | Archives the completed spec and syncs its debt to `.specxis/debt.md`. |
-| `/specxis debt` | Sincroniza todos los comentarios `// lexis:` del código de forma portable. |
+Manage the complete Specxis SDD lifecycle for complex features. Specxis ensures that developer-agent agreements are persisted as lightweight Markdown files in your repository, keeping requirements lean and focused.
+
+#### Subcommands in Detail:
+
+* **`/specxis status` (Shortcut: `/specxis`)**
+  * **What it does:** Lists all active specifications in `.specxis/active/`, displaying their current status (draft/agreed/implementing/done), task completion progress (e.g., `3/5 tasks checked`), and whether a review has been completed. It also shows a summary of archived specs and open debt.
+  * **When to use:** Use this as your central dashboard to see what features are currently in development and their progress.
+
+* **`/specxis new <slug>`**
+  * **What it does:** Creates a new spec folder at `.specxis/active/[slug]/` and initializes a `proposal.md` file from the Specxis template. It prompts you with the *lazy check* ("Does this feature need to exist? What is the absolute minimum?") to challenge the requirement before planning.
+  * **When to use:** Run this when starting a complex feature that touches 3+ files or requires UX/backend coordination.
+
+* **`/specxis plan <slug>`**
+  * **What it does:** Reads your `proposal.md`, applies the lazy decision hierarchy, and generates `spec.md` (MUST/SHOULD/MAY) and `tasks.md` (a technical task list, max 10 tasks, with each task mapping to exactly one file or function).
+  * **When to use:** Run this once the initial proposal is aligned to generate a structured, actionable implementation plan.
+
+* **`/specxis implement <slug>`**
+  * **What it does:** Finds the first unchecked task in your `tasks.md`, implements it following the `spec.md` MUST requirements and `AGENTS.md` rules, and marks the task as completed (`- [x]`). It implements exactly one task per run to ensure maximum control and quality.
+  * **When to use:** Use this to guide the AI agent step-by-step through the implementation of your feature.
+
+* **`/specxis review <slug>`**
+  * **What it does:** Runs a read-only evaluation of the current implementation against the requirements in `spec.md` and the rules of `AGENTS.md`. It writes its findings (Severity, Location, Issue, Fix) to `review.md`.
+  * **When to use:** Run this after implementing your tasks to verify that the feature is fully compliant and clean before closing.
+
+* **`/specxis close <slug>`**
+  * **What it does:** Verifies that all tasks are completed and no Critical/High findings are open. It then moves the spec folder to `.specxis/archive/[slug]/`, harvests any `// lexis:` comments added during development, and appends them to your global `.specxis/debt.md` ledger.
+  * **When to use:** Run this when your feature is fully implemented, tested, and ready to be archived.
+
+* **`/specxis debt`**
+  * **What it does:** Recursively scans the codebase for `// lexis:` comments and synchronizes them with `.specxis/debt.md` using a highly portable Node.js script.
+  * **When to use:** Run this to keep your technical debt ledger perfectly in sync with your codebase.
 
 ---
 
@@ -239,10 +316,13 @@ Make it easy to adopt Lexis in any new project.
 - [ ] `AGENTS.template.md` — project-level AGENTS.md template with commented sections (stack, design tokens, glossary, conventions)
 - [x] `docs/portability.md` — hosts, commands, skills, install paths
 - [x] `docs/site.md` — GitHub Pages + `lexis-two.excelso.xyz`
-- [ ] `docs/setup.md` — detailed installation guide per host
+- [x] `docs/setup.md` — installer guide (phase A1; OpenCode merge in A2)
 - [ ] `docs/modes.md` — when to use lite / full / ultra and how to create custom modes
-- [ ] `npx lexis-two install` — setup script that detects the host (cursor, windsurf, opencode…) and copies the right files
+- [x] `npx lexis-two install` — setup script (phase A1: rules-only hosts)
 - [ ] README improvements with real `// lexis:` comment examples showing before/after simplifications
+- [x] `examples/nextjs/01-modal-library` — gold-standard before/after (B1)
+- [x] `examples/nextjs/` + `examples/express/` — six before/after cases (B2)
+- [x] `examples/fastapi/` — three before/after cases (B3)
 
 ---
 
@@ -255,8 +335,8 @@ Full, verified support across all major hosts.
 - [x] Codex adapter (`.codex-plugin/plugin.json` + `hooks/hooks.json`)
 - [x] pi adapter (`pi-extension/`)
 - [x] Verified skills working in Gemini CLI, Codex, and pi
-- [x] `examples/` — real before/after cases with `// lexis:` comments across the stack (Next.js, Express, MongoDB, PostgreSQL)
-- [ ] `docs/contributing.md` — how to add a new adapter or skill
+- [x] `examples/` — nine before/after cases across Next.js, Express, FastAPI (B1–B3)
+- [x] `CONTRIBUTING.md` — how to add a new adapter or skill
 
 ---
 
@@ -309,9 +389,9 @@ The commercial evolution. Defined once v1.0 has traction.
 
 ## Contributing
 
-Contributions welcome. Before opening a PR, read `AGENTS.md` — it applies here too.
+Contributions welcome. Read [CONTRIBUTING.md](./CONTRIBUTING.md) for architecture, host/skill/command checklists, and the PR contract. [AGENTS.md](./AGENTS.md) applies to this repo too.
 
-Focus areas: stack-specific shortcuts for other tech stacks, new modes, additional commands.
+Focus areas: stack-specific shortcuts for other tech stacks, new examples, additional hosts, installer improvements.
 
 ---
 

package/hooks/lexis-two-mode-tracker.js

@@ -13,21 +13,32 @@ process.stdin.on('end', () => {
     const data = JSON.parse(input.replace(/^\uFEFF/, ''));
     const prompt = (data.prompt || '').trim().toLowerCase();
 
-    // Match /lexis-two commands
-    if (/^[/@$]lexis-two/.test(prompt)) {
+    // Match /lexis-two, /lexis, or /specxis commands
+    if (/^[/@$](lexis-two|lexis|specxis)/.test(prompt)) {
       const parts = prompt.split(/\s+/);
       const cmd = parts[0].replace(/^[@$]/, '/');
       const arg = parts[1] || '';
 
       let mode = null;
 
-      if (cmd === '/lexis-two-review' || cmd === '/lexis-two:lexis-two-review') {
+      if (
+        cmd === '/lexis-two-review' ||
+        cmd === '/lexis-two:lexis-two-review' ||
+        cmd === '/lexis:review' ||
+        cmd === '/lexis:r'
+      ) {
         mode = 'review';
-      } else if (cmd === '/lexis-two' || cmd === '/lexis-two:lexis-two') {
+      } else if (
+        cmd === '/lexis-two' ||
+        cmd === '/lexis-two:lexis-two' ||
+        cmd === '/lexis' ||
+        cmd === '/lexis:lexis'
+      ) {
         if (arg === 'lite') mode = 'lite';
         else if (arg === 'full') mode = 'full';
         else if (arg === 'ultra') mode = 'ultra';
         else if (arg === 'off') mode = 'off';
+        else if (arg === 'review' || arg === 'r') mode = 'review';
         else mode = getDefaultMode();
       }
 

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "@draig/lexis-two",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "description": "The simple way to obtain the best code. Portable rules, skills, and slash commands for AI agents with lowest tokens usage.",
+  "bin": {
+    "lexis-two": "scripts/install.js"
+  },
   "main": "./.opencode/plugins/lexis-two.mjs",
   "exports": {
     ".": "./.opencode/plugins/lexis-two.mjs",
@@ -13,14 +16,21 @@
     "tui"
   ],
   "files": [
+    "AGENTS.md",
+    ".cursor/rules/lexis-two.mdc",
+    ".windsurf/rules/lexis-two.md",
+    ".clinerules/lexis-two.md",
+    ".kiro/steering/lexis-two.md",
+    ".github/copilot-instructions.md",
     ".opencode/plugins/lexis-two.mjs",
     ".opencode/plugins/lexis-two-tui.mjs",
-    ".opencode/command/",
+    ".opencode/commands/",
     "commands/",
     "hooks/",
     "skills/",
     "templates/",
-    "scripts/"
+    "scripts/",
+    "pi-extension/index.js"
   ],
   "keywords": [
     "pi-package",