openprompt-lang 1.4.0 → 1.6.0

package/docs/FRAMEWORK.md

@@ -186,37 +186,6 @@ npx openPrompt-Lang work-context learn
 npx openPrompt-Lang work-context report
 ```
 
-### Plan y Modo (Planificación Ágil)
-```
-opl plan                          → Cambiar a modo PLAN (bloquea tools de escritura)
-opl execute                       → Cambiar a modo EXECUTE (requiere plan aprobado)
-opl mode                          → Mostrar modo actual (plan/execute)
-opl workflow discovery            → E.1 — Wizard de descubrimiento (8 bloques, 29 preguntas)
-opl workflow specification        → E.2 — Generar documentos y diagramas Mermaid
-opl workflow delivery             → E.3 — Iniciar desarrollo por tickets
-opl workflow close                → E.4 — Cerrar sesión y documentar aprendizajes
-```
-
-### Teaching (Enseñanza Adaptativa)
-```
-opl teach progress                → Dashboard de progreso
-opl teach template <id>           → Lección desde template @teachMe
-opl teach assess                  → Diagnosticar nivel de dominio
-opl teach study                   → Unidad pedagógica adaptada
-opl teach project-guide           → Ruta de aprendizaje con tickets
-```
-
-### Ticket, Memoria y Diagnóstico
-```
-opl ticket create --title "..."   → Crear ticket de trabajo
-opl ticket list                   → Listar tickets (--status ready|backlog|done)
-opl ticket close <id>             → Cerrar ticket
-opl recall "consulta"             → Búsqueda en memoria del proyecto
-opl doctor                        → Diagnóstico del sistema OPL
-opl fix                           → Auto-corrección de errores
-opl rebuild                       → Reconstrucción de configuración
-```
-
 ### QA, Extracción y AI
 ```
 npx openPrompt-Lang qa-gen [--lang L] [--source DIR] [--output DIR] [--dry-run] [--no-scan]
@@ -228,12 +197,6 @@ npx openPrompt-Lang db-rules [--list] [--id ID] [--tag TAG]
 npx openPrompt-Lang scaffold folders FRAMEWORK [--name N] [--force]
 ```
 
-### MCP Servers
-```
-npx openPrompt-Lang mcp           → Iniciar servidor MCP principal (tools OPL)
-npx openPrompt-Lang mcp-plan      → Iniciar servidor MCP de planificación (tools plan_*)
-```
-
 ### MCP Server
 ```
 npx openPrompt-Lang mcp
@@ -271,21 +234,6 @@ npx openPrompt-Lang mcp
 | `work_context_start` | Iniciar sesión con tracking | `task` (req), `domain?` |
 | `work_context_status` | Estado actual de la sesión | — |
 | `work_context_close` | Cerrar sesión y registrar métricas | `summary` (req) |
-| `teach_progress` | Mostrar progreso de aprendizaje | `userId?`, `domain?` |
-| `teach_assess` | Diagnosticar nivel de dominio | `conceptId` (req), `domain?` |
-| `teach_study` | Generar unidad pedagógica adaptada | `conceptId` (req), `level?`, `includeExercises?` |
-
-### Servidor OPL-Plan (tools adicionales)
-
-| Herramienta | Descripción | Parámetros |
-|------------|-------------|------------|
-| `plan_recommend_stack` | Analizar proyecto y recomendar stack | `description` (req) |
-| `plan_wizard` | Wizard interactivo de configuración | `project_name` (req), `context` (req) |
-| `plan_create` | Crear plan formal @workflow | `project_name` (req), `language` (req), `stack` (req) |
-| `plan_validate` | Validar que el plan esté completo | `plan_id?` |
-| `plan_status` | Mostrar estado del plan actual | `plan_id?` |
-| `plan_switch_mode` | Cambiar a EXECUTE mode | `plan_id?` |
-| `plan_knowledge_filter` | Filtrar biblioteca por dominio | `domain` (req), `features?` |
 
 ## 11. Reglas Estrictas
 
@@ -329,8 +277,8 @@ Explorar: `opl system list` para ver los 10 sistemas disponibles.
 | fundamentals | Fundamentos de programación y lenguajes | 8/8 |
 | architecture | Arquitectura de software y patrones de diseño transversales | 5/5 |
 | typescript | TypeScript: sistema de tipos, patrones, React+TS, tooling | 0/0 |
-| saas | Patrones SaaS: licenciamiento, monetización, multi-tenant, soft-lock, POS | 0/1 |
-| restaurant | Dominio gastronómico: POS, KDS, delivery, inventario, microservicios | 0/1 |
+| saas | Patrones SaaS: licenciamiento, monetización, multi-tenant, soft-lock, POS | 1/1 |
+| restaurant | Dominio gastronómico: POS, KDS, delivery, inventario, microservicios | 1/1 |
 
 ### Catálogo de Libros
 
@@ -369,9 +317,9 @@ Explorar: `opl system list` para ver los 10 sistemas disponibles.
 | scrum-y-xp-desde-las-trincheras | scrum-y-xp-desde-las-trincheras | 122 | 185 | native | ✓ |
 | typescript-introduccion-adictos-trabajo | typescript-introduccion-adictos-trabajo | 9 | 7 | native | ✓ |
 | flow-api-docs | Flow API — Documentación de Integración de Pagos | 49 | 45 | web | ✓ |
-| 97-cosas-que-todo-programador-deberia-saber | 97 Cosas Que Todo Programador Debería Saber | 186 | 120 | native |  |
-| proyecto-microservicios-restaurant-springboot | Proyecto Real: Microservicios Restaurant Spring Boot | 280 | 12 | analysis |  |
-| proyecto-saas-distribuidora-retamal | Proyecto Real: SaaS Distribuidora Retamal | 260 | 12 | analysis |  |
+| 97-cosas-que-todo-programador-deberia-saber | 97 Cosas Que Todo Programador Debería Saber | 186 | 120 | native | ✓ |
+| proyecto-microservicios-restaurant-springboot | Proyecto Real: Microservicios Restaurant Spring Boot | 280 | 12 | analysis | ✓ |
+| proyecto-saas-distribuidora-retamal | Proyecto Real: SaaS Distribuidora Retamal | 260 | 12 | analysis | ✓ |
 
 ### Playbooks Disponibles
 
@@ -488,8 +436,8 @@ knowledge_concept → { bookId, conceptSlug? }
 ## 14. Stack del Proyecto
 
 - **Lenguaje:** node
-- **Stack base:** node, javascript, esm, commander
-- **Extensiones:** vitest, eslint, inquirer, chalk, pdf-parse
+- **Stack base:** node, javascript, esm, commander, mcp
+- **Extensiones:** vitest, eslint, inquirer, chalk, pdf-parse, ajv
 - **Perfil:** senior
 - **Modo oscuro:** por defecto
 - **Testing:** Vitest

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openprompt-lang",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "PromptLang CLI — Context Engine de anotaciones para desarrollo asistido por IA",
   "type": "module",
   "main": "./bin/cli.js",

package/src/cli/commands-context.js

@@ -192,4 +192,73 @@ export function register(program) {
       const { patternList } = await import("../commands/pattern.js")
       await patternList(options)
     })
+
+  // ── from commands-init.js ──
+  const init = program
+    .command("init")
+    .description("Inicializar proyecto o biblioteca de conocimiento personal")
+    .option("--name <name>", "Nombre del proyecto")
+    .option("--describe <text>", "Descripción del proyecto para sugerencia IA")
+    .option("--existing", "Configurar en proyecto existente (solo archivos de configuración)")
+    .option(
+      "--rebuild",
+      "Reconstruir integración OPL en proyecto existente (force-regenera archivos generados, aplica migraciones)"
+    )
+    .option("--knowledge", "Configurar biblioteca de conocimiento personal (~/.opl/knowledge/)")
+    .option("--dry-run", "Previsualizar sin crear archivos")
+    .option(
+      "--stack <items>",
+      "Stack base (separado por comas, ej: react,typescript,vite,tailwind)"
+    )
+    .option(
+      "--preset <name>",
+      "Usar preset pre-ensamblado (ej: react-supabase-stripe, vue-firebase-netlify)"
+    )
+    .option("--list-presets", "Listar presets disponibles y salir")
+    .option("--list-stacks", "Listar stacks disponibles y salir")
+    .option(
+      "--learn-from <file>",
+      "Ruta a perfil de aprendizaje (aprendizaje-perfil.json) para heredar patrones"
+    )
+    .option("--plan-only", "Solo crear estructura básica + plan MCP, sin preguntar stack")
+    .option("--no-interactive", "Saltar preguntas interactivas y usar defaults")
+    .action(async (options) => {
+      if (options.knowledge) {
+        const { initKnowledgeRepo } = await import("../commands/opl-init-knowledge.js")
+        await initKnowledgeRepo(options)
+        return
+      }
+      if (options.listStacks) {
+        const { listStacks } = await import("../commands/init.js")
+        await listStacks()
+        return
+      }
+      if (options.listPresets) {
+        const { listPresets } = await import("../commands/init.js")
+        await listPresets()
+        return
+      }
+      const { init } = await import("../commands/init.js")
+      await init(options)
+    })
+
+  program
+    .command("figma")
+    .description("Generar prompt para diseño en Figma con convenciones React + Tailwind")
+    .action(async () => {
+      const { figma } = await import("../commands/figma.js")
+      await figma()
+    })
+
+  program
+    .command("suggest")
+    .description("Sugerir o aplicar anotaciones automáticamente en archivos del proyecto")
+    .option("--auto-kind", "Inferir @kind para archivos sin anotaciones")
+    .option("--apply", "Aplicar las sugerencias directamente (escribe los archivos)")
+    .option("--dir <path>", "Directorio del proyecto (default: cwd)")
+    .option("--targets <paths>", "Archivos o directorios específicos (separados por coma)")
+    .action(async (options) => {
+      const { suggest } = await import("../commands/suggest.js")
+      await suggest(options)
+    })
 }

package/src/cli/commands-misc.js

@@ -200,10 +200,10 @@ export function register(program) {
 
   program
     .command("mcp-plan")
-    .description("Start MCP Plan server for planning mode via stdio")
+    .description("(merged into main mcp server) Start MCP OPL server — plan tools are included")
     .action(async () => {
-      const { startPlanServer } = await import("../mcp-plan-server.js")
-      await startPlanServer()
+      const { startServer } = await import("../mcp-server.js")
+      await startServer()
     })
 
   // ──────────────────────────────────────────────
@@ -263,7 +263,7 @@ export function register(program) {
       console.log(`  Workflow:   ${state.workflow_compliant ? "✅ compliant" : "⏳ pendiente"}`)
       console.log("")
       if (state.mode === "plan") {
-        console.log(chalk.gray("  💡 Para empezar a planificar, usa plan_wizard o abre opencode."))
+        console.log(chalk.gray("  💡 Para empezar a planificar, usa plan_create o abre opencode."))
       } else {
         console.log(chalk.gray("  💡 Para implementar, usa analyze_project como primer paso."))
       }
@@ -440,4 +440,217 @@ export function register(program) {
       const { initExisting } = await import("../commands/init-existing.js")
       await initExisting({ rebuild: true, dir: options.dir || process.cwd() })
     })
+
+  // ── from commands-ai.js ──
+  program
+    .command("ai-gen")
+    .description("Generate components from natural language descriptions")
+    .option("--description <text>", "Description of what to generate")
+    .option("--name <name>", "Component name (auto-suggested if omitted)")
+    .option("--lang <lang>", "Language module (default: react)")
+    .option("--profile <profile>", "senior | mid | junior (default: mid)")
+    .option(
+      "--provider <provider>",
+      "AI provider: openai | anthropic | ollama | mock (default: auto-detect)"
+    )
+    .option("--output <dir>", "Output directory (default: src/components)")
+    .option("--force", "Overwrite existing files without asking")
+    .option("--validate", "Run annotation validation after generation")
+    .option("--verbose", "Show prompt and extended output")
+    .option("--temperature <num>", "Temperature for generation (default: 0.3)")
+    .option("--max-tokens <num>", "Max tokens for generation (default: 4096)")
+    .action(async (options) => {
+      const { aiGen } = await import("../commands/ai-gen.js")
+      await aiGen(options)
+    })
+
+  program
+    .command("ai-providers")
+    .description("List available AI providers and their status")
+    .action(async () => {
+      const { aiProviders } = await import("../commands/ai-gen.js")
+      await aiProviders()
+    })
+
+  program
+    .command("learn")
+    .description("Aprender desde documentación: genera módulos de lenguaje usando IA")
+    .option("--docs <paths...>", "Rutas a archivos/directorios de documentación")
+    .option("--from <paths...>", "Proyectos reales para extraer patrones (opcional)")
+    .option("--name <name>", "Nombre del lenguaje (si no se puede detectar automáticamente)")
+    .option(
+      "--output <dir>",
+      "Directorio de salida (default: ~/.openprompt/knowledge/langs/<name>)"
+    )
+    .option("--update <dir>", "Actualizar módulo existente en lugar de crear nuevo")
+    .option("--integrate", "Copiar el módulo generado a src/templates/langs/ (solo maintainers)")
+    .option("--dry-run", "Analizar y mostrar preview sin escribir archivos")
+    .option("--provider <provider>", "AI provider: openai | anthropic | ollama | mock")
+    .action(async (options) => {
+      const { learn } = await import("../commands/learn.js")
+      await learn(options)
+    })
+
+  // ── from commands-lang.js ──
+  const lang = program.command("lang").description("Gestionar módulos de lenguaje plugables")
+
+  lang
+    .command("list")
+    .description("Listar lenguajes disponibles")
+    .action(async () => {
+      const { langList } = await import("../commands/lang.js")
+      await langList()
+    })
+
+  lang
+    .command("index <langId>")
+    .description("Mostrar índice de templates de un lenguaje")
+    .option("--category <category>", "Filtrar por categoría")
+    .action(async (langId, options) => {
+      const { langIndex } = await import("../commands/lang.js")
+      await langIndex(langId, options)
+    })
+
+  lang
+    .command("search <query>")
+    .description("Buscar templates en todos los lenguajes")
+    .option("--lang <lang>", "Filtrar por lenguaje")
+    .action(async (query, options) => {
+      const { langSearch } = await import("../commands/lang.js")
+      await langSearch(query, options)
+    })
+
+  lang
+    .command("errors [langId]")
+    .description("Mostrar errores aprendidos")
+    .option("--template <id>", "Filtrar por template ID")
+    .action(async (langId, options) => {
+      const { langErrors } = await import("../commands/lang.js")
+      await langErrors(langId || "react", options)
+    })
+
+  // ── from commands-knowledge.js ──
+  const knowledge = program
+    .command("knowledge")
+    .description("Gestionar repositorio de conocimiento: ingesta y proceso de PDFs")
+
+  knowledge
+    .command("init")
+    .description("Inicializar estructura knowledge/ en el proyecto")
+    .action(async () => {
+      const { init } = await import("../commands/knowledge.js")
+      await init()
+    })
+
+  knowledge
+    .command("ingest <file>")
+    .description("Procesar un PDF: extraer texto, detectar capítulos y almacenar")
+    .option("--ocr", "Forzar OCR incluso si el PDF tiene texto nativo")
+    .option("--auto-ocr", "Detectar automáticamente si necesita OCR (baja densidad de texto)")
+    .option("--force", "Re-procesar PDF aunque ya exista en el índice")
+    .option("--verbose", "Mostrar progreso detallado (especialmente OCR)")
+    .option("--no-embed", "Saltar la generación automática de embeddings")
+    .action(async (file, options) => {
+      const { ingest } = await import("../commands/knowledge.js")
+      await ingest(file, options)
+    })
+
+  knowledge
+    .command("list")
+    .description("Listar PDFs procesados con metadatos")
+    .option(
+      "--domain <domain>",
+      "Filtrar por dominio (programming, reports, business, legal, product, technical-writing)"
+    )
+    .action(async (options) => {
+      const { list } = await import("../commands/knowledge.js")
+      await list(options)
+    })
+
+  knowledge
+    .command("status [id]")
+    .description("Mostrar estado detallado de uno o todos los PDFs procesados")
+    .action(async (id) => {
+      const { status } = await import("../commands/knowledge.js")
+      await status(id)
+    })
+
+  knowledge
+    .command("to-learning")
+    .description("Integrar PDFs procesados a la memoria semántica (learning)")
+    .option("--all", "Procesar todos los PDFs disponibles")
+    .option("--pdf <id>", "Integrar solo un PDF específico por ID")
+    .option("--force", "Re-integran aunque ya estn integrados")
+    .action(async (options) => {
+      const { toLearning } = await import("../commands/knowledge.js")
+      await toLearning(options)
+    })
+
+  knowledge
+    .command("rebuild")
+    .description("Reconstruir índice desde metadatos individuales")
+    .action(async () => {
+      const { rebuild } = await import("../commands/knowledge.js")
+      await rebuild()
+    })
+
+  knowledge
+    .command("sync")
+    .description("Sincronizar y activar libros desde la biblioteca empaquetada de npm")
+    .option("--all", "Activar todos los libros disponibles sin preguntar")
+    .action(async (options) => {
+      const { sync } = await import("../commands/knowledge.js")
+      await sync(options)
+    })
+
+  knowledge
+    .command("synthesize <topic>")
+    .description(
+      "Sintetizar nuevo conocimiento: crea estructura, valida con sandbox, indexa embeddings"
+    )
+    .option("--dry-run", "Solo preparar estructura sin indexar")
+    .option("--validate <cmd>", "Comando de validación (ej: node test.js)")
+    .option("--domain <domain>", "Dominio del nuevo conocimiento")
+    .action(async (topic, options) => {
+      const { synthesize } = await import("../commands/knowledge.js")
+      await synthesize(topic, options)
+    })
+
+  // ── scar: Anti-conocimiento ────────────────────────────────────────
+
+  const scar = program.command("scar").description("Anti-conocimiento: gestiona cicatrices de guerra (@scar)")
+
+  scar
+    .command("list")
+    .description("Lista todos los scars registrados")
+    .option("--category <cat>", "Filtrar por categoria (bug, error-pattern, anti-pattern, regression)")
+    .option("--severity <sev>", "Filtrar por severidad (blocker, critical, warning, info)")
+    .action(async (options) => {
+      const { listScarsAction } = await import("../commands/scar.js")
+      await listScarsAction(options)
+    })
+
+  scar
+    .command("search <query>")
+    .description("Busca scars por texto en id, symptom, cause, fix")
+    .action(async (query) => {
+      const { searchScarsAction } = await import("../commands/scar.js")
+      await searchScarsAction(query)
+    })
+
+  scar
+    .command("show <id>")
+    .description("Muestra detalle de un scar especifico")
+    .action(async (id) => {
+      const { showScarAction } = await import("../commands/scar.js")
+      await showScarAction(id)
+    })
+
+  scar
+    .command("stats")
+    .description("Estadisticas de anti-conocimiento")
+    .action(async () => {
+      const { statsScarAction } = await import("../commands/scar.js")
+      await statsScarAction()
+    })
 }

package/src/cli/commands-opl.js

@@ -286,6 +286,18 @@ export function register(program) {
       await embeddings("remove", { docId })
     })
 
+  embeddings
+    .command("index-all")
+    .description("Indexar todos los documentos disponibles en el conocimiento")
+    .option("--strategy <s>", "Estrategia de chunking: section, paragraph, fixed", "section")
+    .option("--provider <p>", "Proveedor de embeddings: ollama, transformers")
+    .option("--dry-run", "Simular indexación sin persistir")
+    .option("--resume", "Saltar chunks ya indexados")
+    .action(async (options) => {
+      const { embeddings } = await import("../commands/opl-embeddings.js")
+      await embeddings("index-all", options)
+    })
+
   embeddings
     .command("config")
     .description("Ver o configurar el proveedor de embeddings")

package/src/cli/commands-teach.js

@@ -87,4 +87,53 @@ export function register(program) {
         conceptId: options.conceptId,
       })
     })
+
+  // ── from commands-learning.js ──
+  const learning = program
+    .command("learning")
+    .description("Gestionar memoria semántica: conceptos, variantes y relaciones")
+
+  learning
+    .command("init")
+    .description("Inicializar sistema de memoria semántica")
+    .action(async () => {
+      const { init } = await import("../commands/learning.js")
+      await init()
+    })
+
+  learning
+    .command("search <query>")
+    .description("Buscar conceptos por nombre, tipo o tag")
+    .option("--category <cat>", "Filtrar por categoría (visual, ui, backend, product, ai)")
+    .option("--domain <domain>", "Filtrar por dominio (programming, reports, business, etc.)")
+    .action(async (query, options) => {
+      const { search } = await import("../commands/learning.js")
+      await search(query, options)
+    })
+
+  learning
+    .command("add <name>")
+    .description("Crear un nuevo concepto con template")
+    .option("--category <cat>", "Categoría del concepto (default: visual)")
+    .option("--tags <tags>", "Tags separados por coma (ej: modal,accesibilidad)")
+    .action(async (name, options) => {
+      const { add } = await import("../commands/learning.js")
+      await add(name, options)
+    })
+
+  learning
+    .command("map")
+    .description("Generar mapa visual (Mermaid) desde el grafo de relaciones")
+    .action(async () => {
+      const { map } = await import("../commands/learning.js")
+      await map()
+    })
+
+  learning
+    .command("import-personal <file>")
+    .description("Importar documento de vocabulario personal (formato ### Término + descripción)")
+    .action(async (file) => {
+      const { importPersonal } = await import("../commands/learning.js")
+      await importPersonal(file)
+    })
 }

package/src/cli/commands-workflow.js

@@ -7,13 +7,11 @@
  * Registra los comandos de workflow OPL.
  *
  * Comandos:
- *   opl workflow discovery      → E.1 — Wizard de descubrimiento
- *   opl workflow specification  → E.2 — Generación de documentos
- *   opl workflow delivery       → E.3 — Desarrollo por tickets
- *   opl workflow close          → E.4 — Cierre de sesión
- *   opl workflow select         → E.5 — Selector inteligente de workflow
- *   opl epic                    → E.6 — Gestión de épicas
- *   opl sprint                  → E.7 — Gestión de sprints
+ *   opl workflow delivery       → E.1 — Desarrollo por tickets
+ *   opl workflow close          → E.2 — Cierre de sesión
+ *   opl workflow select         → E.3 — Selector inteligente de workflow
+ *   opl epic                    → E.4 — Gestión de épicas
+ *   opl sprint                  → E.5 — Gestión de sprints
  */
 
 export function register(program) {
@@ -23,39 +21,9 @@ export function register(program) {
   const workflow = program
     .command("workflow")
     .description(
-      "Gestionar workflows de proyecto: discovery, specification, delivery, close, select"
+      "Gestionar workflows de proyecto: delivery, close, select"
     )
 
-  workflow
-    .command("discovery")
-    .description("Iniciar wizard de descubrimiento del proyecto (8 bloques, 29 preguntas)")
-    .option("-p, --project <id>", "ID del proyecto")
-    .option("-f, --force", "Re-ejecutar aunque exista discovery previo")
-    .option("-b, --blocks <blocks>", "Bloques específicos (comma-separado)")
-    .action(async (options) => {
-      const { discovery } = await import("../commands/workflow/discovery/index.js")
-      await discovery({
-        projectId: options.project,
-        force: options.force || false,
-        blocks: options.blocks ? options.blocks.split(",") : undefined,
-      })
-    })
-
-  workflow
-    .command("specification")
-    .description("Generar documentación del proyecto desde el wizard")
-    .option("-p, --project <id>", "ID del proyecto")
-    .option("-t, --templates <templates>", "Templates específicos (comma-separado)")
-    .option("-o, --output <dir>", "Directorio de salida (default: docs/project)")
-    .action(async (options) => {
-      const { specification } = await import("../commands/workflow/specification/index.js")
-      await specification({
-        projectId: options.project,
-        templates: options.templates ? options.templates.split(",") : undefined,
-        outputDir: options.output,
-      })
-    })
-
   workflow
     .command("delivery")
     .description("Iniciar desarrollo por tickets (seleccionar o crear ticket)")
@@ -190,4 +158,94 @@ export function register(program) {
       const { sprintClose } = await import("../commands/workflow/sprint-cli.js")
       await sprintClose(sprintId)
     })
+
+  // ── from commands-work.js ──
+  const workContext = program
+    .command("work-context")
+    .description(
+      "Gestionar contexto de trabajo (integrado con 'opl workflow' — start≈delivery, close≈close)"
+    )
+
+  workContext
+    .command("init")
+    .description("Inicializar sistema work-context en proyecto existente")
+    .action(async () => {
+      const { init } = await import("../commands/work-context.js")
+      await init()
+    })
+
+  workContext
+    .command("status")
+    .description("Mostrar estado actual del contexto de trabajo")
+    .action(async () => {
+      const { status } = await import("../commands/work-context.js")
+      await status()
+    })
+
+  workContext
+    .command("start <description>")
+    .description("Iniciar una nueva sesión de trabajo")
+    .action(async (description) => {
+      const { start } = await import("../commands/work-context.js")
+      await start(description)
+    })
+
+  workContext
+    .command("log <message>")
+    .description("Añadir entrada a la bitácora")
+    .action(async (message) => {
+      const { log } = await import("../commands/work-context.js")
+      await log(message)
+    })
+
+  const planCmd = workContext.command("plan").description("Gestionar planes de trabajo")
+
+  planCmd
+    .command("new <name>")
+    .description("Crear un nuevo plan de trabajo")
+    .option("--task <description>", "Descripción de la tarea para búsqueda de conocimiento")
+    .action(async (name, options) => {
+      const { plan } = await import("../commands/work-context.js")
+      await plan(name, options)
+    })
+
+  planCmd
+    .command("check [name]")
+    .description("Verificar un plan existente contra el conocimiento actual")
+    .action(async (name) => {
+      const { planCheck } = await import("../commands/work-context.js")
+      await planCheck(name)
+    })
+
+  workContext
+    .command("close")
+    .description("Cerrar la sesión activa y generar reporte")
+    .action(async () => {
+      const { close } = await import("../commands/work-context.js")
+      await close()
+    })
+
+  workContext
+    .command("learn")
+    .description("Extraer aprendizajes de la sesión a LEARNINGS.md")
+    .action(async () => {
+      const { learn } = await import("../commands/work-context.js")
+      await learn()
+    })
+
+  workContext
+    .command("report")
+    .description("Generar reporte completo del contexto de trabajo")
+    .action(async () => {
+      const { report } = await import("../commands/work-context.js")
+      await report()
+    })
+
+  workContext
+    .command("check")
+    .description("Verificar consistencia del work-context")
+    .action(async () => {
+      const { check } = await import("../commands/work-context.js")
+      await check()
+    })
 }