@draig/lexis-two 1.0.7 → 1.0.9

package/.opencode/command/lexis.md

@@ -0,0 +1,17 @@
+---
+description: "Manage Lexis senior dev mode, intensity levels, and quality/security tools"
+---
+
+Manage Lexis senior dev mode, intensity levels, and quality/security tools.
+
+Usage:
+- `/lexis` or `/lexis status`: Show current mode and status.
+- `/lexis lite` / `/lexis full` / `/lexis ultra` / `/lexis off`: Switch the intensity level of the ruleset.
+- `/lexis plan` (or `/lexis p`): Plan a feature using the lazy hierarchy before coding.
+- `/lexis review` (or `/lexis r`): Review current changes for over-engineering.
+- `/lexis audit` (or `/lexis a`): Audit the entire repository for over-engineering.
+- `/lexis debt` (or `/lexis d`): Harvest all `// lexis:` comments into a tracked ledger.
+- `/lexis security` (or `/lexis s`): Run a focused security audit on the stack.
+- `/lexis help` (or `/lexis h`): Show the quick reference card.
+
+Respond in Spanish.

package/.opencode/command/specxis.md

@@ -0,0 +1,18 @@
+---
+description: "Manage the Specxis Spec-Driven Development lifecycle (new, plan, implement, review, close, debt, status)"
+---
+
+Manage the Specxis Spec-Driven Development lifecycle.
+
+Usage:
+- `/specxis` or `/specxis status`: Show active specs, tasks progress, and debt.
+- `/specxis new <slug>`: Create a new spec folder and proposal.md.
+- `/specxis plan <slug>`: Generate spec.md and tasks.md from proposal.md.
+- `/specxis implement <slug>`: Implement the next unchecked task.
+- `/specxis review <slug>`: Review the implementation against spec.md and AGENTS.md.
+- `/specxis close <slug>`: Archive the completed spec and sync its debt.
+- `/specxis debt`: Sync all `// lexis:` comments from the codebase to `.specxis/debt.md`.
+
+If `.specxis/` does not exist, suggest running `node node_modules/@draig/lexis-two/scripts/specxis-init.js` (or local script path if in development).
+
+Respond in Spanish.

package/README.md

@@ -1,7 +1,6 @@
 <p align="center">
   <picture>
-  <!--  <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png"> -->
-    <img src="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,6 +28,12 @@ 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**.
@@ -89,7 +94,8 @@ To enable the slash commands globally in any project:
 
 ```bash
 mkdir -p ~/.config/opencode/commands
-cp .opencode/command/lexis-two*.md ~/.config/opencode/commands/
+cp .opencode/command/lexis*.md ~/.config/opencode/commands/
+cp .opencode/command/specxis*.md ~/.config/opencode/commands/
 ```
 
 ### OpenCode (Local development / manual)
@@ -129,15 +135,84 @@ More hosts (Windsurf, Gemini CLI, pi, Copilot): see [docs/portability.md](./docs
 
 ## Commands
 
-Once installed, these slash commands are available in OpenCode:
+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 unified command.
+
+#### Subcommands in Detail:
+
+* **`/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. 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.
 
-| Command               | What it does                                                          |
-| --------------------- | --------------------------------------------------------------------- |
-| `/lexis-two-review`   | Reviews recent changes against AGENTS.md rules                        |
-| `/lexis-two-audit`    | Full codebase audit — over-engineering, deps, structure               |
-| `/lexis-two-debt`     | Surfaces all `// lexis:` comments as prioritized debt list            |
-| `/lexis-two-plan`     | Plans a feature using the minimalist decision hierarchy before coding |
-| `/lexis-two-security` | Security audit focused on your stack (Node.js, MongoDB, Next.js)      |
+* **`/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.
 
 ---
 
@@ -166,7 +241,7 @@ Lexis marks intentional simplifications with inline comments:
 // lexis: tech debt — revisit when auth module is stable
 ```
 
-Run `/lexis-two-debt` to collect and prioritize all tagged items across the codebase.
+Run `/lexis debt` (or `/lexis d`) to collect and prioritize all tagged items across the codebase.
 
 ---
 
@@ -250,17 +325,17 @@ The public orchestrator — a generalized pattern extracted from the private Lex
 
 ---
 
-### v0.5 — Specxis (Spec-Driven Development)
+### v0.5 — Specxis (Spec-Driven Development) ✅
 
 Lightweight SDD layer for complex features — inspired by OpenSpec and Spec Kit,
 built for the Lexis philosophy.
 
-- [ ] `.specxis/` folder convention documented
-- [ ] Commands: specxis-new, specxis-plan, specxis-implement, specxis-review, specxis-close, specxis-debt
-- [ ] Skills: specxis, specxis-plan, specxis-review, specxis-close
-- [ ] `scripts/specxis-init.js` — creates .specxis/ structure in any project
-- [ ] `templates/specxis/` — proposal, spec, and tasks templates
-- [ ] `docs/specxis.md` — when to use SDD vs direct implementation
+- [x] `.specxis/` folder convention documented
+- [x] Commands: specxis-new, specxis-plan, specxis-implement, specxis-review, specxis-close, specxis-debt
+- [x] Skills: specxis, specxis-plan, specxis-review, specxis-close
+- [x] `scripts/specxis-init.js` — creates .specxis/ structure in any project
+- [x] `templates/specxis/` — proposal, spec, and tasks templates
+- [x] `docs/specxis.md` — when to use SDD vs direct implementation
 - [ ] Integration guide for Lexis-One private config
 
 ---

package/commands/lexis-two-audit.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-audit"
+description = "Audit the whole repo for over-engineering, what can be deleted"
+skill = "../skills/lexis-two-audit/SKILL.md"

package/commands/lexis-two-debt.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-debt"
+description = "Harvest all lexis: comments into a prioritized debt ledger"
+skill = "../skills/lexis-two-debt/SKILL.md"

package/commands/lexis-two-help.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-help"
+description = "Quick reference for lexis-two levels, skills, and commands"
+prompt = "Show the lexis-two quick reference. One shot, change nothing: do not switch mode, write flag files, or persist anything. Levels: /lexis-two lite, /lexis-two (full, default), /lexis-two ultra. Commands: /lexis-two-review, /lexis-two-audit, /lexis-two-debt, /lexis-two-plan, /lexis-two-security, /lexis-two-help."

package/commands/lexis-two-plan.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-plan"
+description = "Plan a feature using the Lexis-Two lazy decision hierarchy before any code is written"
+skill = "../skills/lexis-two-plan/SKILL.md"

package/commands/lexis-two-review.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-review"
+description = "Review current diff for over-engineering and Lexis-Two rule violations"
+skill = "../skills/lexis-two-review/SKILL.md"

package/commands/lexis-two-security.toml

@@ -0,0 +1,3 @@
+name = "lexis-two-security"
+description = "Security audit focused on Node.js / TypeScript / Next.js / MongoDB stack"
+skill = "../skills/lexis-two-security/SKILL.md"

package/commands/lexis-two.toml

@@ -0,0 +1,3 @@
+name = "lexis-two"
+description = "Switch lexis-two intensity level (lite/full/ultra/off)"
+prompt = "Switch to lexis-two {{args}} mode. If no level specified, use full. Lazy senior dev mode, before any code: does it need to exist at all (YAGNI)? Does the standard library do it? A native platform feature? Can it be one line? Build the minimum that works. No unrequested abstractions, no avoidable dependencies, no boilerplate. Mark intentional simplifications with a lexis: comment."

package/commands/lexis.toml

@@ -0,0 +1,3 @@
+name = "lexis"
+description = "Manage Lexis senior dev mode, intensity levels, and quality/security tools"
+prompt = "Manage Lexis senior dev mode. Handle the requested subcommand: plan (p), review (r), audit (a), debt (d), security (s), help (h), status, or intensity level (lite/full/ultra/off)."

package/commands/specxis.toml

@@ -0,0 +1,3 @@
+name = "specxis"
+description = "Manage the Specxis Spec-Driven Development lifecycle (new, plan, implement, review, close, debt, status)"
+skill = "../skills/specxis/SKILL.md"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@draig/lexis-two",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "The simple way to obtain the best code. Portable rules, skills, and slash commands for AI agents with lowest tokens usage.",
   "main": "./.opencode/plugins/lexis-two.mjs",
   "exports": {
@@ -16,9 +16,11 @@
     ".opencode/plugins/lexis-two.mjs",
     ".opencode/plugins/lexis-two-tui.mjs",
     ".opencode/command/",
+    "commands/",
     "hooks/",
     "skills/",
-    "scripts/opencode-wrapper-postinstall.mjs"
+    "templates/",
+    "scripts/"
   ],
   "keywords": [
     "pi-package",

package/scripts/check-rule-copies.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// lexis-two — rule copy integrity check
+//
+// To avoid runtime overhead, instruction-tier hosts (Windsurf, Cline, Kiro,
+// Cursor) load static copies of the rules. This script acts as a build/CI guard
+// to ensure those copies never drift from the canonical source (AGENTS.md).
+//
+// It asserts that:
+//   1. Every rule copy file exists.
+//   2. Every copy is completely identical to AGENTS.md (ignoring host-specific frontmatter).
+//   3. The canonical AGENTS.md itself contains the load-bearing Lexis-Two rules.
+
+const fs = require('fs');
+const path = require('path');
+
+const root = path.join(__dirname, '..');
+
+// Canonical source of truth
+const SOURCE_FILE = 'AGENTS.md';
+
+// Static copies to validate
+const COPIES = [
+  '.windsurf/rules/lexis-two.md',
+  '.clinerules/lexis-two.md',
+  '.kiro/steering/lexis-two.md',
+  '.cursor/rules/lexis-two.mdc',
+];
+
+// Load-bearing phrases that MUST exist in the source of truth. If these are
+// missing, the source file has been gutted, and the copies are validating
+// against an empty shell.
+const INVARIANTS = [
+  'lazy senior',
+  'Input validation at trust boundaries',
+  'YAGNI',
+];
+
+function read(relPath) {
+  try {
+    return fs.readFileSync(path.join(root, relPath), 'utf8');
+  } catch (e) {
+    console.error(`Error: failed to read ${relPath}`);
+    process.exit(1);
+  }
+}
+
+// 1. Validate canonical source
+const source = read(SOURCE_FILE);
+for (const phrase of INVARIANTS) {
+  if (!source.includes(phrase)) {
+    console.error(`Error: canonical source (${SOURCE_FILE}) is missing load-bearing rule: "${phrase}"`);
+    process.exit(1);
+  }
+}
+
+// Helper to strip frontmatter (metadata blocks between '---' at start of file)
+function stripFrontmatter(content) {
+  return content.replace(/^---[\s\S]*?---\s*/, '');
+}
+
+// 2. Validate copies
+let failed = false;
+const canonicalBody = stripFrontmatter(source).trim();
+
+for (const copyPath of COPIES) {
+  const copyContent = read(copyPath);
+  const copyBody = stripFrontmatter(copyContent).trim();
+
+  if (copyBody !== canonicalBody) {
+    console.error(`Drift detected: ${copyPath} does not match ${SOURCE_FILE}`);
+    failed = true;
+  }
+}
+
+if (failed) {
+  console.error('\nIntegrity check FAILED. Rule copies have drifted from AGENTS.md.');
+  console.error('To fix, copy AGENTS.md content into the drifted files, preserving their frontmatter if any.');
+  process.exit(1);
+}
+
+console.log('Rule copy integrity check PASSED.');
+process.exit(0);

package/scripts/specxis-debt.js

@@ -0,0 +1,121 @@
+// scripts/specxis-debt.js
+// Portable Node.js script to scan the codebase for "// lexis:" comments
+// and sync them with .specxis/debt.md.
+// Works on Windows, macOS, and Linux.
+
+const fs = require('fs');
+const path = require('path');
+
+const DEBT_FILE = '.specxis/debt.md';
+
+// Recursive directory scan
+function scanDir(dir, fileList = []) {
+  if (!fs.existsSync(dir)) return fileList;
+  const files = fs.readdirSync(dir);
+  for (const file of files) {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      // Skip common ignore folders
+      if (['node_modules', '.git', '.specxis', '.astro', 'dist', 'build', '.cache'].includes(file)) continue;
+      scanDir(filePath, fileList);
+    } else {
+      // Only scan relevant code files
+      if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(path.extname(file))) {
+        fileList.push(filePath);
+      }
+    }
+  }
+  return fileList;
+}
+
+function findLexisComments() {
+  const files = scanDir('.');
+  const comments = [];
+  const regex = /\/\/\s*lexis:\s*(.*)/gi;
+
+  for (const file of files) {
+    const content = fs.readFileSync(file, 'utf8');
+    const lines = content.split(/\r?\n/);
+    lines.forEach((line, index) => {
+      let match;
+      // Reset regex lastIndex
+      regex.lastIndex = 0;
+      while ((match = regex.exec(line)) !== null) {
+        comments.push({
+          file: file.replace(/\\/g, '/'), // normalize to forward slashes
+          line: index + 1,
+          comment: match[1].trim()
+        });
+      }
+    });
+  }
+  return comments;
+}
+
+function syncDebt() {
+  if (!fs.existsSync(DEBT_FILE)) {
+    console.error(`Error: ${DEBT_FILE} does not exist. Run specxis-init first.`);
+    process.exit(1);
+  }
+
+  const found = findLexisComments();
+  console.log(`Found ${found.length} '// lexis:' comments in codebase.`);
+
+  let debtContent = fs.readFileSync(DEBT_FILE, 'utf8');
+
+  // We want to reconstruct or append to .specxis/debt.md.
+  // Let's create a prioritized ledger as described in SPECXIS.md.
+  // Categories:
+  // - Immediate: shortcuts causing pain or blocking features
+  // - Next sprint: shortcuts with a known ceiling approaching
+  // - Backlog: fine for now, revisit at scale
+  // - Permanent: intentional, no action needed
+  
+  const immediate = [];
+  const nextSprint = [];
+  const backlog = [];
+  const permanent = [];
+
+  found.forEach(item => {
+    const text = item.comment.toLowerCase();
+    const entry = `- [ ] **${item.file}:${item.line}**: ${item.comment}`;
+
+    if (text.includes('immediate') || text.includes('critical') || text.includes('pain') || text.includes('block')) {
+      immediate.push(entry);
+    } else if (text.includes('sprint') || text.includes('soon') || text.includes('ceiling')) {
+      nextSprint.push(entry);
+    } else if (text.includes('permanent') || text.includes('intentional') || text.includes('no action')) {
+      permanent.push(`- **${item.file}:${item.line}**: ${item.comment} (Permanent)`);
+    } else {
+      backlog.push(entry);
+    }
+  });
+
+  const header = `# Specxis Debt Ledger
+
+Consolidated // lexis: comments across all features.
+Updated automatically by /specxis-debt and /specxis-close.
+
+---
+
+## Prioritized Ledger
+
+### Immediate (shortcuts causing pain or blocking features)
+${immediate.length > 0 ? immediate.join('\n') : '*No immediate debt found.*'}
+
+### Next Sprint (shortcuts with a known ceiling approaching)
+${nextSprint.length > 0 ? nextSprint.join('\n') : '*No next sprint debt found.*'}
+
+### Backlog (fine for now, revisit at scale)
+${backlog.length > 0 ? backlog.join('\n') : '*No backlog debt found.*'}
+
+### Permanent (intentional, no action needed)
+${permanent.length > 0 ? permanent.join('\n') : '*No permanent debt found.*'}
+`;
+
+  fs.writeFileSync(DEBT_FILE, header);
+  console.log(`Updated ${DEBT_FILE} with prioritized ledger.`);
+}
+
+syncDebt();

package/scripts/specxis-init.js

@@ -0,0 +1,45 @@
+// scripts/specxis-init.js
+// Initializes .specxis/ folder structure in the current project.
+// Run with: node scripts/specxis-init.js
+
+const fs = require('fs');
+const path = require('path');
+
+const dirs = [
+  '.specxis/active',
+  '.specxis/archive',
+];
+
+const debtTemplate = `# Specxis Debt Ledger
+
+Consolidated // lexis: comments across all features.
+Updated automatically by /specxis-debt and /specxis-close.
+
+---
+
+<!-- Entries added by specxis-close and specxis-debt commands -->
+`;
+
+for (const dir of dirs) {
+  fs.mkdirSync(dir, { recursive: true });
+  console.log(`created ${dir}/`);
+}
+
+const debtPath = '.specxis/debt.md';
+if (!fs.existsSync(debtPath)) {
+  fs.writeFileSync(debtPath, debtTemplate);
+  console.log(`created ${debtPath}`);
+}
+
+// Add .specxis/archive to .gitignore if not already there
+// (active specs stay in git; archive is optional)
+const gitignorePath = '.gitignore';
+if (fs.existsSync(gitignorePath)) {
+  const content = fs.readFileSync(gitignorePath, 'utf8');
+  if (!content.includes('.specxis/archive')) {
+    fs.appendFileSync(gitignorePath, '\n# Specxis archived specs (optional)\n# .specxis/archive\n');
+    console.log('added .specxis/archive comment to .gitignore');
+  }
+}
+
+console.log('\nSpecxis initialized. Run /specxis-new to create your first spec.');

package/skills/specxis/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: specxis
+description: Manage the Specxis Spec-Driven Development lifecycle (new, plan, implement, review, close, debt, status)
+---
+
+You are the Specxis orchestrator. Handle the requested subcommand or action:
+
+### 1. STATUS (default: `/specxis` or `/specxis status`)
+- List folders in `.specxis/active/`. For each, show: slug, status (draft/agreed/implementing/done), task progress (X/Y), and if review.md exists.
+- List count of archived specs in `.specxis/archive/`.
+- Show open items in `.specxis/debt.md` by priority.
+
+### 2. NEW (`/specxis new <slug>`)
+- Ask for slug if not provided (kebab-case, e.g. "user-auth").
+- Create `.specxis/active/[slug]/proposal.md` from the template in `node_modules/@draig/lexis-two/templates/specxis/proposal.md` (or local path).
+- Apply the lazy check: ask "Does this need to exist? What's the minimum?". Fill what you know, leave unknowns blank.
+
+### 3. PLAN (`/specxis plan <slug>`)
+- Read `.specxis/active/[slug]/proposal.md`.
+- Apply the lazy hierarchy to every requirement.
+- Create `.specxis/active/[slug]/spec.md` (MUST/SHOULD/MAY) and `.specxis/active/[slug]/tasks.md` (max 10 tasks, one per file/function).
+- Ask for approval before starting implementation.
+
+### 4. IMPLEMENT (`/specxis implement <slug>`)
+- Read `.specxis/active/[slug]/tasks.md`. Find the first unchecked task (`- [ ]`).
+- Implement it following spec.md MUST requirements and AGENTS.md rules.
+- Mark as done (`- [x]`), add `// lexis:` comments for deviations, and update "Lexis Tags Added" in tasks.md.
+- Implement only one task per run. Stop and report.
+
+### 5. REVIEW (`/specxis review <slug>`)
+- Read `.specxis/active/[slug]/spec.md` and run `git diff HEAD`.
+- Evaluate spec compliance, SHOULD compliance, AGENTS.md rules, and tests.
+- Write findings to `.specxis/active/[slug]/review.md` (Severity: Critical/High/Medium/Low, Location, Issue, Fix).
+
+### 6. CLOSE (`/specxis close <slug>`)
+- Verify all tasks are checked and no Critical/High findings are open.
+- Move `.specxis/active/[slug]/` to `.specxis/archive/[slug]/`.
+- Collect all `// lexis:` comments added during this feature and append them to `.specxis/debt.md`.
+
+### 7. DEBT (`/specxis debt`)
+- Run `node node_modules/@draig/lexis-two/scripts/specxis-debt.js` (or local path) to scan the codebase and update `.specxis/debt.md` with a prioritized ledger.
+
+---
+
+If `.specxis/` does not exist, suggest running `node node_modules/@draig/lexis-two/scripts/specxis-init.js` first.
+Respond in Spanish. All code, comments, JSDoc in English.

package/templates/specxis/proposal.md

@@ -0,0 +1,21 @@
+# Proposal: [feature-slug]
+
+## Goal
+One sentence — what does this feature do for the user?
+
+## Lazy Check
+Answer before writing any code:
+- Does this need to exist? Could the requirement be met another way?
+- Does stdlib, the framework, or an installed dep already cover it?
+- What is the absolute minimum that satisfies the requirement?
+
+## Context
+- Affected domain / feature folder:
+- Related existing files:
+- Dependencies already installed that are relevant:
+
+## Out of Scope (YAGNI)
+Explicitly list what this proposal does NOT include.
+
+## Open Questions
+Anything that needs clarification before planning.

package/templates/specxis/review.md

@@ -0,0 +1,17 @@
+# Review: [feature-slug]
+
+> Generated by /specxis-review on close.
+
+## Summary
+One sentence on overall quality.
+
+## Spec Compliance
+Did the implementation follow spec.md?
+- MUST requirements met: yes / no / partial
+- Deviations: list with // lexis: references
+
+## Debt Registered
+// lexis: comments added during this feature — moved to .specxis/debt.md.
+
+## Next Steps
+Recommended follow-up actions in priority order.

package/templates/specxis/spec.md

@@ -0,0 +1,24 @@
+# Spec: [feature-slug]
+
+> Status: draft | agreed | implementing | done
+
+## Requirements
+
+### MUST (non-negotiable)
+- [ ] 
+
+### SHOULD (strong preference, can deviate with // lexis: comment)
+- [ ] 
+
+### MAY (optional, implement only if trivial)
+- [ ] 
+
+## Constraints
+- Performance:
+- Security:
+- Accessibility:
+- TypeScript: strict — no any, as, or ! without // lexis: explanation
+
+## Acceptance Criteria
+How do we know this is done?
+- [ ] 

package/templates/specxis/tasks.md

@@ -0,0 +1,16 @@
+# Tasks: [feature-slug]
+
+> Generated by /specxis-plan. Each task maps to one file or one function.
+> Do not start implementing until tasks are agreed.
+
+## Tasks
+
+- [ ] task-001: 
+- [ ] task-002: 
+- [ ] task-003: 
+
+## Implementation Notes
+Decisions made during planning that affect implementation.
+
+## Lexis Tags Added
+// lexis: comments added during implementation (updated as work progresses).