openprompt-lang 1.2.4 → 1.2.7

package/src/mcp-server-backup.js

@@ -1,1913 +0,0 @@
-#!/usr/bin/env node
-
-import {
-  readFileSync,
-  writeFileSync,
-  readdirSync,
-  existsSync,
-  statSync,
-  rmSync,
-  mkdirSync,
-} from "fs"
-import { join, extname, dirname } from "path"
-import { fileURLToPath } from "url"
-import { lintFile } from "./utils/annotations.js"
-import { loadConfig, getDefaultConfig } from "./utils/config.js"
-import {
-  searchTemplates,
-  getTemplate,
-  getLanguage,
-  getLanguageIndex,
-  getLanguages,
-} from "./utils/language-loader.js"
-import { scanForLearnErrors, generateTests, writeTestFile } from "./utils/error-learner.js"
-import { scaffoldFolders } from "./commands/scaffold.js"
-import { extractLesson, extractTags } from "./utils/template-utils.js"
-import { findAllFiles, countFiles } from "./utils/file-utils.js"
-import {
-  searchKnowledge,
-  knowledgeList as kList,
-  knowledgeRead,
-  knowledgeConcept,
-} from "./utils/knowledge-search.js"
-import { searchKnowledge as kSearchTemplates } from "./utils/knowledge-search.js"
-import {
-  loadDomains,
-  classifyBook,
-  getBooksByDomain,
-  expandConcept,
-  searchByDomain,
-  listAllDomainsWithInfo,
-} from "./utils/knowledge-taxonomy.js"
-import {
-  getSessionState,
-  saveSessionState,
-  recordToolCall,
-  setActiveDomain,
-  markValidated,
-  setPhase,
-  setPlanFile,
-} from "./mcp-session.js"
-import {
-  checkPreconditions,
-  prepareToolResponse,
-  generateRichInstructions,
-  shouldAutoTicket,
-} from "./mcp-workflow.js"
-
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-function getServerVersion() {
-  try {
-    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"))
-    return pkg.version || "0.9.0"
-  } catch {
-    return "0.9.0"
-  }
-}
-
-const SUPPORTED_PROTOCOL_VERSIONS = ["2024-11-05"]
-const LATEST_PROTOCOL_VERSION = SUPPORTED_PROTOCOL_VERSIONS[0]
-
-const SERVER_INFO = {
-  name: "OPL",
-  version: getServerVersion(),
-}
-
-const TOOLS = [
-  {
-    name: "validate",
-    description:
-      "[PRE-COMMIT CHECK] Scan project for annotation errors. Use BEFORE commits or when troubleshooting annotation warnings. Returns file-by-file errors and warnings. If errors found, use lint_file on specific files to debug.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "Path to file to validate" },
-        dir: { type: "string", description: "Directory to scan for files (default: cwd)" },
-      },
-    },
-  },
-  {
-    name: "lint_file",
-    description:
-      "[FILE LINTING] Debug a single file's annotations in detail. Returns parsed annotations, errors, and warnings. More detailed than validate for individual files. Use strict mode for thorough checking.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        filePath: { type: "string", description: "Path to the source file" },
-        strict: { type: "boolean", description: "Enable strict mode (warnings become errors)" },
-      },
-      required: ["filePath"],
-    },
-  },
-  {
-    name: "parse_code",
-    description:
-      "[QUICK PARSE] Validate annotation syntax inline without reading from disk. Use during code generation or editing to verify annotation syntax before writing to file.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        code: { type: "string", description: "Source code containing @annotations" },
-      },
-      required: ["code"],
-    },
-  },
-  {
-    name: "context",
-    description:
-      "[CONTEXT EXTRACTION] Extract project structure with config summary and annotated file list. Use when you need a bird's-eye view of the project or before generating documentation.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        dir: { type: "string", description: "Project directory (default: cwd)" },
-        scope: { type: "string", description: "Filter by @scope module name" },
-      },
-    },
-  },
-  {
-    name: "search_templates",
-    description:
-      "[TEMPLATE DISCOVERY] Find relevant templates before using teach_template. Searches by keyword (button, auth, fetch, form). Returns matching templates with descriptions and metadata.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query" },
-        lang: { type: "string", description: "Language module (react, vue)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "generate_tests",
-    description:
-      "[TEST GENERATION] Generate Vitest test cases from @learn-error annotations. AFTER documenting a bug with @learn-error, run this to create regression tests. Optionally write to file with output parameter.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sourceDir: { type: "string", description: "Source directory to scan (default: cwd)" },
-        lang: { type: "string", description: "Language module (react, vue)" },
-        output: { type: "string", description: "Output path for generated test file (optional)" },
-      },
-    },
-  },
-  {
-    name: "teach_template",
-    description:
-      "[LEARN PATTERNS] Show structured lesson and code from a template. Use when implementing a known pattern (button, auth, form, fetch). Takes templateId like 'button-shadcn' or 'hook-useAuth'. Returns lesson, best practices, fix history, and optionally the code. Run search_templates first to find relevant templates.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        templateId: {
-          type: "string",
-          description: "Template ID to teach (e.g. button-shadcn, hook-useAuth)",
-        },
-        lang: { type: "string", description: "Language module (react, vue)" },
-        showCode: { type: "boolean", description: "Include full template code in output" },
-      },
-      required: ["templateId"],
-    },
-  },
-  {
-    name: "analyze_project",
-    description:
-      "[PROJECT AUDIT] First tool to run when starting work on an unknown project. Returns config summary, file counts by type, and annotation stats. Use to understand project structure before making changes.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        dir: { type: "string", description: "Project directory (default: cwd)" },
-      },
-    },
-  },
-  {
-    name: "init_project",
-    description:
-      "[PROJECT INIT] Initialize a new openPrompt-Lang project. Creates prompt-lang.json, AGENTS.md, and base directory structure. Use for fresh projects before scaffold_project.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: "Project name" },
-        dir: { type: "string", description: "Target directory (default: cwd)" },
-        stack: {
-          type: "string",
-          description: "Stack items (comma-separated, e.g. react,typescript,vite,tailwind)",
-        },
-      },
-    },
-  },
-  {
-    name: "component_list",
-    description:
-      "[COMPONENT LIST] List available components from templates and language modules. Use to discover what components exist before generating new ones.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        lang: { type: "string", description: "Language module (react, vue, angular, etc.)" },
-      },
-    },
-  },
-  {
-    name: "scaffold_project",
-    description:
-      "[PROJECT SETUP] Create project folder structure and scaffold files. Use when initializing a new project or adding a module. Takes framework id (react, vue). Creates folders, .gitignore, prompt-lang.json, AGENTS.md.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        framework: { type: "string", description: "Framework/language id (react, vue)" },
-        name: { type: "string", description: "Project subdirectory name (optional)" },
-        force: { type: "boolean", description: "Overwrite existing files" },
-      },
-      required: ["framework"],
-    },
-  },
-  {
-    name: "knowledge_search",
-    description:
-      "[KNOWLEDGE SEARCH] Search across all knowledge sources (books, chapters, concepts, templates) using a text query. Returns ranked results with snippets. Use as primary knowledge lookup when the AI needs information about programming topics, frameworks, or APIs.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: {
-          type: "string",
-          description: 'Search query (e.g. "ownership rust", "react hooks", "payment api")',
-        },
-        category: {
-          type: "string",
-          description:
-            "Filter by category: lenguajes, web, metodologias, algoritmos, api, accesibilidad",
-        },
-        bookId: { type: "string", description: "Filter results to a specific book ID" },
-        limit: { type: "number", description: "Maximum results to return (default: 20)" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "knowledge_list",
-    description:
-      "[KNOWLEDGE LIST] List all available books in the knowledge base with metadata (title, pages, chapters, method). Use to discover what knowledge is available before searching or reading.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        category: { type: "string", description: "Filter by category" },
-      },
-    },
-  },
-  {
-    name: "knowledge_read",
-    description:
-      "[KNOWLEDGE READ] Read the full content of a specific chapter from a book. Use after knowledge_search to get complete content. Returns chapter title, content, and word count.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        bookId: {
-          type: "string",
-          description: 'Book ID (e.g. "rust-libro-espanol", "capacitorjs-docs")',
-        },
-        chapterIndex: {
-          type: "number",
-          description:
-            "Chapter index number (from search results). If omitted, returns first chapter.",
-        },
-      },
-      required: ["bookId"],
-    },
-  },
-  {
-    name: "knowledge_concept",
-    description:
-      "[KNOWLEDGE CONCEPT] Expand a semantic concept from a book, showing its content and related concepts from the knowledge graph. Use to understand relationships between topics.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        bookId: { type: "string", description: "Book ID" },
-        conceptSlug: {
-          type: "string",
-          description: "Specific concept slug to read (if omitted, returns first concept)",
-        },
-      },
-      required: ["bookId"],
-    },
-  },
-  {
-    name: "knowledge_domain",
-    description:
-      "[KNOWLEDGE DOMAIN] List knowledge domains or books within a domain. Use to discover organized knowledge areas (payments, mobile-pwa, systems, qa, etc.). Returns domain descriptions and book counts.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        domain: {
-          type: "string",
-          description:
-            'Domain name to list books for (e.g. "payments", "mobile-pwa", "systems", "qa", "frontend", "backend", "accessibility", "algorithms", "fundamentals"). If omitted, lists all domains.',
-        },
-      },
-    },
-  },
-  {
-    name: "knowledge_playbook",
-    description:
-      "[KNOWLEDGE PLAYBOOK] Read an actionable playbook for a domain. Playbooks contain step-by-step procedures for implementing specific solutions. Available domains: payments, mobile-pwa, systems, qa.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        domain: {
-          type: "string",
-          description: "Domain playbook to read (payments, mobile-pwa, systems, qa)",
-        },
-      },
-      required: ["domain"],
-    },
-  },
-  {
-    name: "recall",
-    description:
-      "[MEMORY RECALL] Search project memory: learnings, concepts, errors, and tickets. Use BEFORE implementing to avoid repeating past mistakes. Saves ~30min of debugging.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query for project memory" },
-        domain: {
-          type: "string",
-          description:
-            "Filter by domain (programming, reports, business, legal, product, technical-writing)",
-        },
-        all: { type: "boolean", description: "Search across all domains" },
-      },
-      required: ["query"],
-    },
-  },
-  {
-    name: "context_unified",
-    description:
-      "[UNIFIED CONTEXT] Cross-source search across 7 sources: knowledge, learning, semantic, templates, tickets, errors, and patterns. Use before planning to gather all relevant project context. Saves ~20min of research.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        query: { type: "string", description: "Search query across all sources" },
-        domain: { type: "string", description: "Filter by active domain" },
-      },
-    },
-  },
-  {
-    name: "domain_status",
-    description:
-      "[DOMAIN STATUS] Show active domains, file counts, pattern counts, and context loaded. Use to understand what domains and patterns are active in the current context.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-    },
-  },
-  {
-    name: "work_context_status",
-    description:
-      "[WORK SESSION STATUS] Show current work session state: phase, tools called, plan status, domain. Use before starting any work to know where you are in the workflow.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-    },
-  },
-  {
-    name: "work_context_plan",
-    description:
-      "[WORK PLAN] Create a work plan for the current task. Use BEFORE implementing to avoid going in wrong directions. Saves ~1hr of rework.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        task: { type: "string", description: "Task description for the plan" },
-        domain: {
-          type: "string",
-          description: "Domain for this plan (programming, reports, etc.)",
-        },
-      },
-      required: ["task"],
-    },
-  },
-  {
-    name: "work_context_start",
-    description:
-      "[WORK SESSION START] Start or resume a work session. Tracks what tools are called and workflow phase. Enable workflow enforcement when session is active.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        task: { type: "string", description: "Task being started" },
-        domain: { type: "string", description: "Active domain for this session" },
-      },
-    },
-  },
-  {
-    name: "work_context_close",
-    description:
-      "[WORK SESSION CLOSE] Close the current work session. Records metrics, lessons learned, and validates state. REQUIRES work_context_start to have been called.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        summary: { type: "string", description: "Summary of what was accomplished" },
-      },
-    },
-  },
-  {
-    name: "workflow_check",
-    description:
-      "[WORKFLOW GATE] Check what steps are still needed in the current workflow. Returns a checklist of completed vs pending steps. Use to verify you are following the optimal flow that saves time.",
-    inputSchema: {
-      type: "object",
-      properties: {},
-    },
-  },
-  {
-    name: "teach_progress",
-    description:
-      "[TEACH PROGRESS] Show consolidated learning progress from SQLite. Returns concept-by-concept status (mastered/in_progress/not_started), scores, levels, and next recommended concept. Use before starting a study session to know current state.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        userId: { type: "string", description: "User ID (default: $USER)" },
-        domain: { type: "string", description: "Filter by domain (sql, javascript, etc.)" },
-      },
-    },
-  },
-  {
-    name: "teach_assess",
-    description:
-      "[TEACH ASSESS] Diagnostic level of domain for a concept. Reads progress from SQLite and returns assessed level, score, next level, recommendations, and estimated time. Read-only — does not persist. Use to know user level before teaching.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        userId: { type: "string", description: "User ID (default: $USER)" },
-        conceptId: { type: "string", description: "Concept ID to assess (e.g. joins-sql)" },
-        domain: { type: "string", description: "Domain (e.g. sql, javascript)" },
-      },
-      required: ["conceptId"],
-    },
-  },
-  {
-    name: "teach_study",
-    description:
-      "[TEACH STUDY] Generate a complete adapted pedagogy unit for a concept. Returns objective, prerequisites, explanations, examples, common errors, mastery criteria, and exercises. Adapts to user level automatically from SQLite progress or explicit level parameter.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        userId: { type: "string", description: "User ID (default: $USER)" },
-        conceptId: { type: "string", description: "Concept ID to study (e.g. joins-sql)" },
-        level: {
-          type: "string",
-          description:
-            "Force specific level (recognizes, explains, etc.). Auto-detected from progress if omitted.",
-        },
-        includeExercises: {
-          type: "boolean",
-          description: "Include exercise in response (default: false)",
-        },
-      },
-      required: ["conceptId"],
-    },
-  },
-]
-
-function sendMessage(msg) {
-  const data = JSON.stringify(msg)
-  process.stdout.write(`${data}\n`)
-}
-
-function sendError(id, code, message) {
-  sendMessage({ jsonrpc: "2.0", id, error: { code, message } })
-}
-
-function sendResult(id, result) {
-  sendMessage({ jsonrpc: "2.0", id, result })
-}
-
-function formatResult(type, summary, details, actions) {
-  const parts = [`## Result: ${type}`, "", summary]
-  if (details && details.length) {
-    parts.push("", "### Details", ...details.map((d) => `- ${d}`))
-  }
-  if (actions && actions.length) {
-    parts.push("", "### Recommended Actions", ...actions.map((a) => `- ${a}`))
-  }
-  return parts.join("\n")
-}
-
-function toolResult(text, isError = false) {
-  return { content: [{ type: "text", text }], isError }
-}
-
-async function handleToolCall(name, args) {
-  switch (name) {
-    case "validate": {
-      const dir = args?.dir || args?.filePath || process.cwd()
-      const target = join(process.cwd(), dir)
-      if (!existsSync(target)) return toolResult(`Path not found: ${target}`, true)
-
-      // If target is a directory, scan for annotated files
-      if (statSync(target).isDirectory()) {
-        const allFiles = []
-        function walk(d) {
-          let entries
-          try {
-            entries = readdirSync(d, { withFileTypes: true })
-          } catch {
-            return
-          }
-          for (const e of entries) {
-            if (e.name.startsWith(".") || e.name === "node_modules" || e.name === "dist") continue
-            const p = join(d, e.name)
-            if (e.isDirectory()) walk(p)
-            else if (e.isFile() && /\.(ts|tsx|js|jsx)$/.test(e.name)) allFiles.push(p)
-          }
-        }
-        walk(target)
-        if (allFiles.length === 0) {
-          return toolResult(
-            formatResult(
-              "info",
-              "No source files found in directory.",
-              [`Scanned: ${target}`],
-              ["Run scaffold_project to initialize project structure."]
-            )
-          )
-        }
-        let totalAnn = 0
-        let totalErr = 0
-        let totalWarn = 0
-        const details = []
-        for (const f of allFiles) {
-          const code = readFileSync(f, "utf-8")
-          const result = lintFile(code)
-          totalAnn += result.annotations.length
-          totalErr += result.errors.length
-          totalWarn += result.warnings.length
-          if (result.errors.length || result.warnings.length) {
-            const rel = f.replace(`${target}/`, "")
-            for (const e of result.errors) details.push(`❌ ${rel}: ${e}`)
-            for (const w of result.warnings) details.push(`⚠ ${rel}: ${w}`)
-          }
-        }
-        const status = totalErr > 0 ? "error" : totalWarn > 0 ? "warning" : "success"
-        const actions = []
-        if (totalErr > 0) actions.push("Fix errors listed above, then run validate again")
-        if (totalWarn > 0) actions.push("Review warnings — some may indicate potential issues")
-        if (totalErr === 0 && totalWarn === 0) {
-          actions.push("Project annotations are valid. Ready for commit.")
-        }
-        return toolResult(
-          formatResult(
-            status,
-            `Scanned ${allFiles.length} files: ${totalAnn} annotations, ${totalErr} errors, ${totalWarn} warnings`,
-            details.length ? details : [`✅ All annotations valid across ${allFiles.length} files`],
-            actions
-          )
-        )
-      }
-
-      const result = lintFile(readFileSync(target, "utf-8"))
-      const status =
-        result.errors.length > 0 ? "error" : result.warnings.length > 0 ? "warning" : "success"
-      const actions = []
-      if (result.errors.length > 0) actions.push("Fix errors, then re-run validate on this file")
-      if (result.warnings.length > 0) actions.push("Review warnings before committing")
-      if (result.errors.length === 0 && result.warnings.length === 0) {
-        actions.push("File is valid. No issues found.")
-      }
-      return toolResult(
-        formatResult(
-          status,
-          `File: ${args?.filePath || target}: ${result.annotations.length} annotations, ${result.errors.length} errors, ${result.warnings.length} warnings`,
-          [...result.errors.map((e) => `❌ ${e}`), ...result.warnings.map((w) => `⚠ ${w}`)],
-          actions
-        )
-      )
-    }
-
-    case "lint_file": {
-      const filePath = join(process.cwd(), args.filePath)
-      if (!existsSync(filePath)) {
-        return toolResult(
-          formatResult(
-            "error",
-            "File not found",
-            [`Path: ${filePath}`],
-            ["Verify the file path and try again"]
-          ),
-          true
-        )
-      }
-      const code = readFileSync(filePath, "utf-8")
-      const result = lintFile(code, args.strict)
-      const status =
-        result.errors.length > 0 ? "error" : result.warnings.length > 0 ? "warning" : "success"
-      return toolResult(
-        formatResult(
-          status,
-          `${args.filePath}: ${result.annotations.length} annotations`,
-          [
-            ...result.annotations.map((a) => `@${a.name}(${a.raw})`),
-            ...result.errors.map((e) => `❌ ${e}`),
-            ...result.warnings.map((w) => `⚠ ${w}`),
-          ],
-          result.errors.length
-            ? ["Fix errors and re-run lint_file"]
-            : result.warnings.length
-              ? ["Review warnings"]
-              : ["File is valid"]
-        )
-      )
-    }
-
-    case "parse_code": {
-      if (!args?.code) {
-        return toolResult(
-          formatResult(
-            "error",
-            "No code provided",
-            [],
-            ["Pass a 'code' parameter with annotation source text"]
-          ),
-          true
-        )
-      }
-      const result = lintFile(args.code)
-      const status =
-        result.errors.length > 0 ? "error" : result.warnings.length > 0 ? "warning" : "success"
-      return toolResult(
-        formatResult(
-          status,
-          `${result.annotations.length} annotations found`,
-          [
-            ...result.annotations.map((a) => `@${a.name}(${a.raw})`),
-            ...result.errors.map((e) => `❌ ${e}`),
-            ...result.warnings.map((w) => `⚠ ${w}`),
-          ],
-          result.errors.length ? ["Fix annotation syntax"] : ["Annotation syntax is valid"]
-        )
-      )
-    }
-
-    case "context": {
-      const dir = args?.dir || process.cwd()
-      const cwd = join(process.cwd(), dir)
-      let config = null
-      try {
-        config = loadConfig(cwd)
-      } catch {
-        console.error("[mcp] ⚠ No se pudo cargar configuración en context tool")
-      }
-      const details = [`Directory: ${dir}`, `Config: ${config ? "found" : "none"}`]
-      if (config) {
-        details.push(
-          `Name: ${config.name || "unnamed"}`,
-          `Language: ${config.lenguaje || "unknown"}`,
-          `Stack: ${(config.stack?.base || []).join(", ")}`
-        )
-      }
-      const actions = config
-        ? ["Run validate to check annotation health"]
-        : ["Run init or scaffold_project to create project config"]
-      return toolResult(formatResult("success", "Project context extracted", details, actions))
-    }
-
-    case "search_templates": {
-      const lang = args?.lang || "react"
-      const query = args?.query || ""
-      const results = searchTemplates(query, { lang })
-      if (!results.length) {
-        return toolResult(
-          formatResult(
-            "info",
-            `No templates match "${query}" in ${lang}`,
-            [],
-            ["Try a different query or check available templates with lang list"]
-          )
-        )
-      }
-      return toolResult(
-        formatResult(
-          "success",
-          `${results.length} templates found for "${query}" in ${lang}`,
-          results.map(
-            (t, i) => `${i + 1}. ${t.id}: ${t.description || "no description"} — ${t.category}`
-          ),
-          [
-            "Run teach_template with a template ID to learn more",
-            "Use showCode=true in teach_template to see the implementation",
-          ]
-        )
-      )
-    }
-
-    case "generate_tests": {
-      const sourceDir = args?.sourceDir || process.cwd()
-      const lang = args?.lang || "react"
-      const dir = join(process.cwd(), sourceDir)
-      if (!existsSync(dir)) {
-        return toolResult(formatResult("error", "Directory not found", [`Path: ${dir}`], []), true)
-      }
-      const errors = scanForLearnErrors(dir, lang)
-      if (!errors.length) {
-        return toolResult(
-          formatResult(
-            "info",
-            "No @learn-error annotations found",
-            [`Scanned: ${dir}`],
-            ["After fixing a bug, add @learn-error to the file and re-run generate_tests"]
-          )
-        )
-      }
-      const tests = generateTests(errors, lang)
-      const details = [`Learned errors found: ${errors.length}`, `Tests generated: ${tests.length}`]
-      if (args?.output) {
-        const outPath = join(process.cwd(), args.output)
-        writeTestFile(errors, outPath, lang)
-        details.push(`Written to: ${args.output}`)
-      }
-      const actions = [
-        args?.output
-          ? `Run: npx vitest run ${args.output}`
-          : "Pass 'output' parameter to write test file to disk",
-      ]
-      return toolResult(
-        formatResult(
-          "success",
-          `Generated ${tests.length} tests from ${errors.length} learned errors`,
-          [...details, "", ...tests],
-          actions
-        )
-      )
-    }
-
-    case "teach_template": {
-      const lang = args?.lang || "react"
-      const template = getTemplate(args.templateId, lang)
-      if (!template) {
-        return toolResult(
-          formatResult(
-            "error",
-            `Template "${args.templateId}" not found in ${lang}`,
-            [],
-            [`Run search_templates with keywords to find available templates in ${lang}`]
-          ),
-          true
-        )
-      }
-      const langObj = getLanguage(lang)
-      const meta = template.metadata
-      const details = [
-        `${meta.name}: ${meta.description || ""}`,
-        `Category: ${meta.category}`,
-        `Purposes: ${meta.purposes?.join(", ") || "general"}`,
-      ]
-      if (meta.variants?.length) details.push(`Variants: ${meta.variants.join(", ")}`)
-      if (meta.sizes?.length) details.push(`Sizes: ${meta.sizes.join(", ")}`)
-      details.push(
-        `Dark mode: ${meta.darkMode ? "yes" : "no"}`,
-        `Responsive: ${meta.responsive ? "yes" : "no"}`,
-        `Deps: ${meta.dependencies?.join(", ") || "none"}`
-      )
-      if (meta.hasTeachMe) {
-        const lesson = extractLesson(template.content)
-        if (lesson) details.push("", "--- LESSON ---", lesson)
-      }
-      const goodP = extractTags(template.content, "@goodPractice")
-      const badP = extractTags(template.content, "@badPractice")
-      if (goodP.length) details.push("", "--- GOOD PRACTICES ---", ...goodP.map((g) => `✅ ${g}`))
-      if (badP.length) details.push("", "--- BAD PRACTICES ---", ...badP.map((b) => `❌ ${b}`))
-      if (args?.showCode) {
-        const clean = template.content
-          .split("\n")
-          .filter((l) => !l.trim().startsWith("// @"))
-          .join("\n")
-        details.push("", "--- CODE ---", clean)
-      }
-      const actions = [
-        "Use this pattern in your project",
-        "Run scaffold_project to set up the project structure",
-      ]
-      return toolResult(
-        formatResult("success", `${meta.name} — ${langObj?.name || lang}`, details, actions)
-      )
-    }
-
-    case "analyze_project": {
-      const dir = args?.dir || process.cwd()
-      const cwd = join(process.cwd(), dir)
-      if (!existsSync(cwd)) {
-        return toolResult(formatResult("error", "Directory not found", [`Path: ${cwd}`], []), true)
-      }
-      let config = null
-      try {
-        config = loadConfig(cwd)
-      } catch {
-        console.error("[mcp] ⚠ No se pudo cargar configuración en analyze_project")
-      }
-      const counts = countFiles(cwd)
-      const allFiles = findAllFiles(cwd)
-      const annResults = []
-      for (const f of allFiles) {
-        try {
-          const code = readFileSync(f, "utf-8")
-          const r = lintFile(code)
-          if (r.annotations.length || r.errors.length || r.warnings.length) {
-            annResults.push({ file: f.replace(`${cwd}/`, ""), ...r })
-          }
-        } catch {
-          /* skip unreadable files */
-        }
-      }
-      const details = [
-        `Config: ${config ? "found" : "none"}`,
-        `Name: ${config?.name || "unnamed"}`,
-        `Language: ${config?.lenguaje || "unknown"}`,
-        `Stack: ${(config?.stack?.base || []).join(", ")}`,
-        "",
-        `Total files: ${counts.total}`,
-        `.ts: ${counts.ts} | .tsx: ${counts.tsx} | .js: ${counts.js} | .jsx: ${counts.jsx} | .css: ${counts.css}`,
-        "",
-        `Files with annotations: ${annResults.length}`,
-        ...annResults.map(
-          (r) =>
-            `${r.file}: ${r.annotations.length} annotations, ${r.errors.length} errors, ${r.warnings.length} warnings`
-        ),
-      ]
-      const actions = config
-        ? [
-            "Run validate to check annotation consistency",
-            "Run search_templates to find relevant patterns",
-          ]
-        : ["Run init to set up project configuration"]
-      return toolResult(formatResult("success", `Project analysis: ${dir}`, details, actions))
-    }
-
-    case "init_project": {
-      const targetDir = join(process.cwd(), args?.dir || "")
-      const defaultConfig = {
-        ...getDefaultConfig(),
-        name: args?.name || targetDir.split("/").pop() || "mi-proyecto",
-        stack: args?.stack
-          ? { base: args.stack.split(",").map((s) => s.trim()) }
-          : { base: ["react", "typescript", "vite", "tailwind"] },
-      }
-      try {
-        writeFileSync(
-          join(targetDir, "prompt-lang.json"),
-          JSON.stringify(defaultConfig, null, 2),
-          "utf-8"
-        )
-        writeFileSync(
-          join(targetDir, "AGENTS.md"),
-          `# AGENTS.md — Contexto para IA
-
-## Stack
-- ${defaultConfig.stack.base.join("\n- ")}
-
-## Convenciones
-- Framework: openPrompt-Lang (@kind, @contract, @limit annotations)
-- NO any types
-- NO exceed line limits without refactoring
-- Annotations must declare @use() at file start
-- Run validation before every commit
-`,
-          "utf-8"
-        )
-      } catch (err) {
-        return toolResult(
-          formatResult("error", "Failed to initialize project", [err.message], []),
-          true
-        )
-      }
-      const actions = [
-        "Run scaffold_project <framework> to create folder structure",
-        "Run validate to verify setup",
-      ]
-      return toolResult(
-        formatResult(
-          "success",
-          "Project initialized",
-          [
-            `prompt-lang.json created with stack: ${defaultConfig.stack.base.join(", ")}`,
-            "AGENTS.md created with conventions",
-          ],
-          actions
-        )
-      )
-    }
-
-    case "component_list": {
-      const langFilter = args?.lang
-      const langs = getLanguages(true)
-      const details = []
-      for (const lang of langs) {
-        if (langFilter && lang.id !== langFilter) continue
-        const index = getLanguageIndex(lang.id)
-        const templates = index?.templates || []
-        const withTeach = templates.filter((t) => t.hasTeachMe).length
-        details.push(`**${lang.id}**: ${templates.length} templates (${withTeach} with @teachMe)`)
-        for (const t of templates.slice(0, 5)) {
-          details.push(`  - ${t.id}: ${t.description}`)
-        }
-        if (templates.length > 5) {
-          details.push(`  - ... and ${templates.length - 5} more`)
-        }
-      }
-      if (details.length === 0) {
-        return toolResult(formatResult("info", "No components found", [], []))
-      }
-      return toolResult(
-        formatResult("success", `Components found in ${langFilter || "all languages"}`, details, [
-          "Use teach_template <id> to learn about a specific component",
-        ])
-      )
-    }
-
-    case "scaffold_project": {
-      const output = await scaffoldFolders(args.framework, {
-        name: args?.name,
-        force: args?.force,
-      })
-      if (!output) {
-        return toolResult(
-          formatResult(
-            "error",
-            `Failed to scaffold "${args.framework}"`,
-            [],
-            ["Verify the framework id is valid (react, vue)"]
-          ),
-          true
-        )
-      }
-      return toolResult(
-        formatResult(
-          "success",
-          `Scaffold "${args.framework}" created`,
-          [`Location: ${output}`],
-          ["Run validate to verify structure", "Run knowledge_search to find relevant knowledge"]
-        )
-      )
-    }
-
-    case "knowledge_search": {
-      const ksResult = searchKnowledge(args.query || "", {
-        category: args?.category,
-        bookId: args?.bookId,
-        limit: args?.limit || 20,
-        dir: args?.dir,
-      })
-      if (ksResult.results.length === 0) {
-        return toolResult(
-          formatResult(
-            "empty",
-            `No knowledge found for "${args.query}"`,
-            ["Try a different query or broader terms", "Use knowledge_list to see available books"],
-            []
-          )
-        )
-      }
-      const details = ksResult.results
-        .slice(0, 10)
-        .map(
-          (r) =>
-            `**[${r.type}]** ${r.bookTitle || r.bookId} — ${r.title?.substring(0, 80) || ""}\n   ${r.snippet?.substring(0, 200) || ""} (relevance: ${r.relevance})`
-        )
-      return toolResult(
-        formatResult(
-          "success",
-          `Found ${ksResult.total} results for "${args.query}" (showing ${Math.min(ksResult.results.length, 10)})`,
-          details,
-          [
-            "Use knowledge_read to get full chapter content",
-            "Use knowledge_concept to explore related concepts",
-          ]
-        )
-      )
-    }
-
-    case "knowledge_list": {
-      const books = kList({ category: args?.category, dir: args?.dir })
-      if (books.length === 0) {
-        return toolResult(formatResult("empty", "No knowledge books available", [], []))
-      }
-      const bookLines = books.map(
-        (b) =>
-          `| ${b.id} | ${(b.title || "").substring(0, 50)} | ${b.pages} págs | ${b.chapters?.length || 0} caps | ${b.method} |`
-      )
-      return toolResult(
-        formatResult("success", `${books.length} knowledge books available`, bookLines, [
-          "Use knowledge_search to search within books",
-          "Use knowledge_read to read a chapter",
-        ])
-      )
-    }
-
-    case "knowledge_read": {
-      const chapter = knowledgeRead(args.bookId, args?.chapterIndex, { dir: args?.dir })
-      if (!chapter) {
-        return toolResult(
-          formatResult(
-            "error",
-            `Book "${args.bookId}" not found or no chapters available`,
-            [],
-            ["Use knowledge_list to see available books"]
-          ),
-          true
-        )
-      }
-      const content = chapter.content?.substring(0, 8000) || "No content available"
-      const details = [
-        `**Book:** ${chapter.bookTitle} (${chapter.bookId})`,
-        `**Chapter ${chapter.chapterIndex}:** ${chapter.chapterTitle}`,
-        `**Words:** ${chapter.words} | **Total chapters:** ${chapter.totalChapters}`,
-        "",
-        "---",
-        "",
-        content,
-      ]
-      return toolResult(
-        formatResult(
-          "success",
-          `Chapter ${chapter.chapterIndex} of ${chapter.totalChapters}: "${chapter.chapterTitle}"`,
-          details,
-          []
-        )
-      )
-    }
-
-    case "knowledge_concept": {
-      const concept = knowledgeConcept(args.bookId, args?.conceptSlug, { dir: args?.dir })
-      if (!concept) {
-        return toolResult(
-          formatResult(
-            "error",
-            `Book or concept "${args.bookId}" not found`,
-            [],
-            ["Use knowledge_list to see available books"]
-          ),
-          true
-        )
-      }
-      const relatedLines = concept.related.map((r) => `  - ${r.nodeId} (${r.relation})`).join("\n")
-      const content =
-        (typeof concept.concept === "string" ? concept.concept : "").substring(0, 5000) ||
-        "No content available"
-      const details = [
-        `**Book:** ${concept.bookTitle} (${concept.bookId})`,
-        `**Concept:** ${concept.conceptSlug}`,
-        `**Related concepts:** ${concept.related.length}`,
-        relatedLines,
-        "",
-        "---",
-        "",
-        content,
-      ]
-      return toolResult(
-        formatResult(
-          "success",
-          `Concept: ${concept.conceptSlug} from ${concept.bookTitle}`,
-          details,
-          []
-        )
-      )
-    }
-
-    case "knowledge_domain": {
-      const projectDir = args?.dir || process.cwd()
-      if (args?.domain) {
-        const books = getBooksByDomain(args.domain, projectDir)
-        if (books.length === 0) {
-          return toolResult(
-            formatResult(
-              "empty",
-              `No books found for domain "${args.domain}"`,
-              [],
-              ["Use knowledge_domain without args to list all domains"]
-            ),
-            true
-          )
-        }
-        const bookLines = books.map(
-          (b) =>
-            `| ${b.id} | ${(b.title || "").substring(0, 50)} | ${b.chapters || "?"} caps | ${b.method || "unknown"} |`
-        )
-        return toolResult(
-          formatResult("success", `Domain "${args.domain}": ${books.length} books`, bookLines, [
-            "Use knowledge_search to search within this domain",
-          ])
-        )
-      }
-      const domains = listAllDomainsWithInfo(projectDir)
-      const domainLines = domains.map(
-        (d) =>
-          `| ${d.domain} | ${d.description} | ${d.bookCount} | ${d.playbooks.join(", ") || "—"} |`
-      )
-      return toolResult(
-        formatResult(
-          "success",
-          `${domains.length} knowledge domains available`,
-          [
-            "| Domain | Description | Books | Playbooks |",
-            "|--------|-------------|-------|----------|",
-            ...domainLines,
-          ],
-          [
-            "Use knowledge_domain with a domain name to list its books",
-            "Use knowledge_playbook to read a playbook",
-          ]
-        )
-      )
-    }
-
-    case "knowledge_playbook": {
-      const domain = args.domain
-      const repoDir = args?.dir || process.cwd()
-      const playbookDir = join(repoDir, "knowledge-repo", "playbooks", domain)
-      const pkgPlaybookDir = join(
-        __dirname,
-        "..",
-        "templates",
-        "knowledge-repo",
-        "playbooks",
-        domain
-      )
-      let playbookContent = null
-
-      for (const dir of [playbookDir, pkgPlaybookDir]) {
-        const files = existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith(".md")) : []
-        if (files.length > 0) {
-          playbookContent = readFileSync(join(dir, files[0]), "utf-8")
-          break
-        }
-      }
-
-      if (!playbookContent) {
-        return toolResult(
-          formatResult(
-            "error",
-            `No playbook found for domain "${domain}"`,
-            [],
-            [
-              "Available domains: payments, mobile-pwa, systems, qa",
-              "Use knowledge_domain to list available domains",
-            ]
-          ),
-          true
-        )
-      }
-
-      const content = playbookContent.substring(0, 8000)
-      const details = [`**Domain:** ${domain}`, "", "---", "", content]
-      return toolResult(
-        formatResult("success", `Playbook: ${domain}`, details, [
-          "Use knowledge_search to find specific topics in this domain",
-        ])
-      )
-    }
-
-    case "recall": {
-      const activeDomain = args?.domain || "shared"
-      let output = ""
-      const recallArgs = { domain: args?.domain || activeDomain, all: args?.all }
-
-      // Buscar en learnings acumulados de SQLite
-      let sqliteResults = []
-      try {
-        const { open, close } = await import("./persistence/sqlite/connection.js")
-        const { ensureSchema } = await import("./persistence/sqlite/schema.js")
-        const dbPath = join(process.cwd(), ".opencode/opl.db")
-        const conn = open(dbPath)
-        const { db } = conn
-        ensureSchema(db)
-        const raw = db
-          .prepare("SELECT value FROM project_metadata WHERE key = 'accumulated_learnings'")
-          .get()
-        if (raw) {
-          const learnings = JSON.parse(raw.value)
-          const query = (args?.query || "").toLowerCase()
-          sqliteResults = query
-            ? learnings.filter((l) => l.toLowerCase().includes(query))
-            : learnings
-        }
-        close()
-      } catch {
-        /* SQLite opcional */
-      }
-
-      try {
-        const { recall } = await import("./commands/recall.js")
-        const results = await recall(args?.query || "", recallArgs)
-        if (results) {
-          const parts = []
-          if (results.concepts?.length > 0) {
-            parts.push(
-              `**Conceptos (${results.concepts.length}):** ${results.concepts.map((c) => `${c.name} (${c.category})`).join(", ")}`
-            )
-          }
-          if (results.errors?.length > 0) {
-            parts.push(
-              `**Errores conocidos (${results.errors.length}):** ${results.errors.map((e) => `${e.id}: ${e.problem}`).join("; ")}`
-            )
-          }
-          if (results.tickets?.length > 0) {
-            parts.push(
-              `**Tickets relacionados (${results.tickets.length}):** ${results.tickets.map((t) => `${t.id} — ${t.title}`).join("; ")}`
-            )
-          }
-          if (sqliteResults.length > 0) {
-            parts.push(
-              `**Aprendizajes de sesiones (${sqliteResults.length}):** ${sqliteResults.map((l) => l.substring(0, 100)).join("; ")}`
-            )
-          }
-          output = parts.join("\n\n")
-        } else if (sqliteResults.length > 0) {
-          output = `**Aprendizajes de sesiones (${sqliteResults.length}):** ${sqliteResults.map((l) => l.substring(0, 100)).join("; ")}`
-        }
-      } catch {
-        output =
-          sqliteResults.length > 0
-            ? `**Aprendizajes de sesiones (${sqliteResults.length}):** ${sqliteResults.map((l) => l.substring(0, 100)).join("; ")}`
-            : "Recall executed via memory scan."
-      }
-      if (!output)
-        output = `No se encontró "${args.query}" en la memoria del proyecto (dominio: ${recallArgs.domain}).`
-      return toolResult(
-        formatResult(
-          "success",
-          `Recall: "${args.query}"`,
-          [output],
-          [
-            "Usa estos resultados para evitar repetir errores pasados",
-            "Si no hay resultados, consulta knowledge_search también",
-          ]
-        )
-      )
-    }
-
-    case "context_unified": {
-      try {
-        const activeDomain = args?.domain || "shared"
-        const { contextUnified } = await import("./commands/context.js")
-        const unified = await contextUnified({
-          query: args?.query || "",
-          domain: args?.domain || activeDomain,
-          dir: ".",
-        })
-        if (unified) {
-          const summary = []
-          if (unified.knowledge?.length)
-            summary.push(`Knowledge: ${unified.knowledge.length} resultados`)
-          if (unified.learning?.length)
-            summary.push(`Learning: ${unified.learning.length} conceptos`)
-          if (unified.templates?.length) summary.push(`Templates: ${unified.templates.length}`)
-          if (unified.tickets?.length) summary.push(`Tickets: ${unified.tickets.length}`)
-          if (unified.errors?.length) summary.push(`Errores: ${unified.errors.length}`)
-          if (unified.patterns?.length) summary.push(`Patrones: ${unified.patterns.length}`)
-          const total =
-            unified.knowledge?.length +
-              unified.learning?.length +
-              unified.templates?.length +
-              unified.tickets?.length +
-              unified.errors?.length +
-              unified.patterns?.length || 0
-          return toolResult(
-            formatResult(
-              "success",
-              `Contexto unificado: ${total} resultados en 7 fuentes`,
-              summary,
-              [
-                "Usa estos resultados para planificar antes de implementar",
-                "Considera los patrones existentes antes de crear nuevos",
-              ]
-            )
-          )
-        }
-      } catch {}
-      return toolResult(
-        formatResult(
-          "empty",
-          "Contexto unificado no disponible",
-          [],
-          ["Ejecuta context domain init primero"]
-        )
-      )
-    }
-
-    case "domain_status": {
-      let output = "Dominios activos:"
-      try {
-        const { getActiveDomains } = await import("./utils/domains.js")
-        const active = getActiveDomains()
-        output = `Dominio activo: ${active.join(" + ")}`
-        output += "\n\nUsa este dominio para filtrar knowledge, learning y tickets."
-        output +=
-          "\nComandos: context domain use <domain> | context domain switch <domain> | context domain clear"
-      } catch {
-        output = "Dominios no inicializados. Ejecuta context domain init."
-      }
-      return toolResult(
-        formatResult(
-          "success",
-          output,
-          [],
-          [
-            "Usa context domain use <domain> para cambiar de dominio",
-            "El dominio actual filtra automáticamente knowledge, learning y tickets",
-          ]
-        )
-      )
-    }
-
-    case "work_context_status": {
-      const session = getSessionState()
-      const details = [
-        `**Sesión:** ${session.id}`,
-        `**Fase:** ${session.phase}`,
-        `**Tools llamados:** ${session.tools_called?.join(", ") || "ninguno"}`,
-        `**Plan:** ${session.plan_file || "no creado"}`,
-        `**Validado:** ${session.validated_at || "no"}`,
-        `**Dominio activo:** ${session.active_domain?.join(" + ") || "shared"}`,
-        `**Modo estricto:** ${session.strict_mode ? "sí" : "no (guide mode)"}`,
-      ]
-      if (session.friction_events?.length > 0) {
-        details.push(`**Eventos de fricción:** ${session.friction_events.length}`)
-      }
-      const pendingSteps = []
-      if (!session.tools_called?.includes("analyze_project"))
-        pendingSteps.push("1. analyze_project")
-      if (
-        !session.tools_called?.includes("context_unified") &&
-        !session.tools_called?.includes("knowledge_search") &&
-        !session.tools_called?.includes("recall")
-      ) {
-        pendingSteps.push("2. context_unified o knowledge_search — buscar antes de crear")
-      }
-      if (!session.plan_file)
-        pendingSteps.push("3. work_context_plan — planificar antes de implementar")
-      if (!session.validated_at) pendingSteps.push("4. validate — verificar antes de cerrar")
-
-      return toolResult(
-        formatResult(
-          "success",
-          "Estado de sesión de trabajo",
-          details,
-          pendingSteps.length > 0
-            ? pendingSteps
-            : ["✅ Flujo completo. Puedes cerrar la sesión con work_context_close."]
-        )
-      )
-    }
-
-    case "work_context_plan": {
-      try {
-        const { plan } = await import("./commands/work-context.js")
-        await plan(args.task, {
-          domain: args?.domain || getSessionState()?.active_domain?.[0] || "programming",
-        })
-        const session = getSessionState()
-        const planFile = join(".opencode", "work-context", "PLANS", `plan-${Date.now()}.md`)
-        setPlanFile(session, planFile)
-        saveSessionState(session)
-        return toolResult(
-          formatResult(
-            "success",
-            "Plan de trabajo creado",
-            [
-              `**Tarea:** ${args.task}`,
-              `**Dominio:** ${args?.domain || "programming"}`,
-              `**Plan:** ${planFile}`,
-            ],
-            [
-              "Ahora ejecuta analyze_project para obtener contexto",
-              "Luego busca en knowledge_search antes de implementar",
-            ]
-          )
-        )
-      } catch (err) {
-        return toolResult(
-          formatResult(
-            "error",
-            "Error creando plan",
-            [err.message],
-            ["Verifica que work-context esté inicializado: work-context init"]
-          ),
-          true
-        )
-      }
-    }
-
-    case "work_context_start": {
-      const session = getSessionState()
-      setPhase(session, "active")
-      if (args?.domain) setActiveDomain(session, args.domain)
-      recordToolCall(session, "work_context_start")
-      saveSessionState(session)
-
-      // Cargar nivel de aprendizaje del usuario desde SQLite
-      let userLevelInfo = ""
-      try {
-        const { open, close } = await import("./persistence/sqlite/connection.js")
-        const { ensureSchema } = await import("./persistence/sqlite/schema.js")
-        const dbPath = join(process.cwd(), ".opencode/opl.db")
-        const conn = open(dbPath)
-        const { db } = conn
-        ensureSchema(db)
-        const concepts = db
-          .prepare(
-            "SELECT concept_id, user_level FROM learning_progress ORDER BY updated_at DESC LIMIT 3"
-          )
-          .all()
-        close()
-        if (concepts.length > 0) {
-          userLevelInfo = `**Nivel aprendizaje:** ${concepts.map((c) => `${c.concept_id}: ${c.user_level}`).join(", ")}`
-        }
-      } catch {
-        /* SQLite opcional — no bloquear */
-      }
-
-      const details = [
-        `**Sesión:** ${session.id}`,
-        `**Tarea:** ${args?.task || "no especificada"}`,
-        `**Dominio:** ${session.active_domain?.join(" + ") || "shared"}`,
-        `**Fase:** active`,
-      ]
-      if (userLevelInfo) details.push(userLevelInfo)
-
-      const pendingSteps = []
-      if (!session.tools_called?.includes("analyze_project"))
-        pendingSteps.push("analyze_project — conocer el proyecto")
-      if (!session.tools_called?.includes("context_unified"))
-        pendingSteps.push("context_unified — contexto unificado")
-      return toolResult(
-        formatResult(
-          "success",
-          "Sesión de trabajo iniciada",
-          details,
-          pendingSteps.length > 0
-            ? ["⚠ Pasos recomendados antes de implementar:", ...pendingSteps]
-            : ["✅ Puedes empezar a implementar"]
-        )
-      )
-    }
-
-    case "work_context_close": {
-      const session = getSessionState()
-      const precondition = checkPreconditions("work_context_close")
-      if (!precondition.allowed) {
-        return prepareToolResponse(
-          toolResult(
-            formatResult(
-              "error",
-              "No se puede cerrar sesión",
-              [precondition.reason],
-              ["Ejecuta work_context_start primero"]
-            ),
-            true
-          ),
-          precondition
-        )
-      }
-      setPhase(session, "closed")
-      saveSessionState(session)
-      let autoTicketNote = ""
-      const result = toolResult(
-        formatResult(
-          "success",
-          "Sesión cerrada",
-          [
-            `**Resumen:** ${args?.summary || "completada"}`,
-            `**Tools llamados:** ${session.tools_called?.join(", ") || "ninguno"}`,
-          ],
-          ["La sesión ha sido registrada"]
-        )
-      )
-      if (shouldAutoTicket(session, result)) {
-        autoTicketNote =
-          "\n\n---\n📋 Se ha detectado fricción en el flujo. Considera crear un ticket para mejorar el sistema."
-      }
-      return autoTicketNote
-        ? { ...result, content: [{ type: "text", text: result.content[0].text + autoTicketNote }] }
-        : result
-    }
-
-    case "workflow_check": {
-      const session = getSessionState()
-      const checklist = [
-        {
-          step: "analyze_project",
-          done: session.tools_called?.includes("analyze_project"),
-          rationale: "Conocer el proyecto (30s, ahorra ~15min)",
-        },
-        {
-          step: "context_unified o knowledge_search o recall",
-          done:
-            session.tools_called?.includes("context_unified") ||
-            session.tools_called?.includes("knowledge_search") ||
-            session.tools_called?.includes("recall"),
-          rationale: "Buscar antes de crear (10s, ahorra ~30min)",
-        },
-        {
-          step: "work_context_plan",
-          done: !!session.plan_file,
-          rationale: "Planificar antes de implementar (1min, ahorra ~1hr)",
-        },
-        {
-          step: "validate o lint_file",
-          done:
-            !!session.validated_at ||
-            session.tools_called?.includes("validate") ||
-            session.tools_called?.includes("lint_file"),
-          rationale: "Verificar antes de cerrar (5s, previene bugs)",
-        },
-      ]
-      const doneCount = checklist.filter((c) => c.done).length
-      const details = checklist.map((c) => `${c.done ? "✅" : "⬜"} **${c.step}** — ${c.rationale}`)
-      const actions = checklist
-        .filter((c) => !c.done)
-        .map((c) => `Ejecuta ${c.step.split(" o ")[0]}`)
-      return toolResult(
-        formatResult(
-          doneCount === checklist.length ? "success" : "info",
-          `Workflow: ${doneCount}/${checklist.length} pasos completados`,
-          details,
-          actions.length > 0 ? actions : ["✅ Flujo completo"]
-        )
-      )
-    }
-
-    case "teach_progress": {
-      const { showProgress } = await import("./commands/teach/progress/index.js")
-      const result = await showProgress({
-        userId: args?.userId || process.env.USER || "mcp-user",
-        domain: args?.domain || null,
-        dbPath: join(process.cwd(), ".opencode/opl.db"),
-        json: true,
-        raw: true,
-      })
-      const lines = ["## Learning Progress", ""]
-      if (result.concepts.length === 0) {
-        lines.push("No concepts registered yet. Run `opl teach assess` to start.")
-      } else {
-        lines.push(
-          `**${result.total}** concepts: ${result.mastered} mastered, ${result.inProgress} in progress, ${result.notStarted} not started.`
-        )
-        lines.push("")
-        for (const c of result.concepts) {
-          const icon = c.status === "mastered" ? "🟢" : c.status === "in_progress" ? "🟡" : "⚪"
-          const level = c.currentLevel || "—"
-          const score = c.score !== null ? `${(c.score * 100).toFixed(0)}%` : "—"
-          lines.push(`${icon} **${c.name}** — ${level} (${score})`)
-        }
-        if (result.nextRecommended) {
-          lines.push("")
-          lines.push(`🎯 Next recommended: **${result.nextRecommended}**`)
-        }
-      }
-      return toolResult(lines.join("\n"))
-    }
-
-    case "teach_assess": {
-      // MCP assess: read-only, sin preguntas, usa historial de SQLite
-      const { open, close } = await import("./persistence/sqlite/connection.js")
-      const { ensureSchema } = await import("./persistence/sqlite/schema.js")
-      const { getProgress } = await import("./persistence/sqlite/queries.js")
-      const { assessLevel } = await import("./core/learning/assessor.js")
-      const { getLevel } = await import("./core/learning/levels.js")
-
-      const dbPath = join(process.cwd(), ".opencode/opl.db")
-      const conn = open(dbPath)
-      const { db } = conn
-      ensureSchema(db)
-
-      const userId = args?.userId || process.env.USER || "mcp-user"
-      const conceptId = args?.conceptId
-      const domain = args?.domain || "general"
-
-      if (!conceptId) return toolResult("conceptId is required", true)
-
-      const existing = getProgress(db, conceptId)
-      const history = existing
-        ? {
-            assessedLevel: existing.user_level,
-            scores: existing.assessments_taken > 0 ? { [existing.user_level]: 0.8 } : undefined,
-          }
-        : undefined
-
-      const result = assessLevel({ userId, domain, conceptId, history })
-      const level = getLevel(result.assessedLevel)
-      close()
-
-      const lines = [
-        `## Assessment: ${conceptId}`,
-        "",
-        `**Level:** ${level.label} (${result.assessedLevel})`,
-        `**Score:** ${result.scores[result.assessedLevel] !== null ? `${(result.scores[result.assessedLevel] * 100).toFixed(0)}%` : "—"}`,
-        result.nextLevel
-          ? `**Next:** ${getLevel(result.nextLevel).label}`
-          : "🎉 **Max level reached**",
-        `**Time estimate:** ${result.estimatedTime}`,
-        "",
-        "**Recommendations:**",
-        ...result.recommendations.map((r) => `- ${r}`),
-      ]
-
-      return toolResult(lines.join("\n"))
-    }
-
-    case "teach_study": {
-      // MCP study: genera unidad pedagógica adaptada al nivel del usuario
-      const { open, close } = await import("./persistence/sqlite/connection.js")
-      const { ensureSchema } = await import("./persistence/sqlite/schema.js")
-      const { getProgress } = await import("./persistence/sqlite/queries.js")
-      const { buildTeachMeUnit, adaptUnitToLevel } = await import("./core/learning/pedagogue.js")
-      const { getLevel } = await import("./core/learning/levels.js")
-      const { generateGuidedExercise, generateFreeExercise } =
-        await import("./core/learning/exercise.js")
-      const { scanForLearnErrors } = await import("./utils/error-learner.js")
-
-      const dbPath = join(process.cwd(), ".opencode/opl.db")
-      const conn = open(dbPath)
-      const { db } = conn
-      ensureSchema(db)
-
-      const userId = args?.userId || process.env.USER || "mcp-user"
-      const conceptId = args?.conceptId
-      const explicitLevel = args?.level || null
-      const includeExercises = args?.includeExercises || false
-
-      if (!conceptId) return toolResult("conceptId is required", true)
-
-      // Determinar nivel
-      let userLevel = explicitLevel
-      if (!userLevel) {
-        const existing = getProgress(db, conceptId)
-        userLevel = existing?.user_level || "recognizes"
-      }
-      close()
-
-      try {
-        const fullUnit = buildTeachMeUnit(conceptId, userLevel)
-        const unit = adaptUnitToLevel(fullUnit, userLevel)
-
-        const lines = [
-          `## Study: ${unit.conceptId}`,
-          `**Level:** ${getLevel(userLevel).label}`,
-          "",
-          `**Objective:** ${unit.objective}`,
-          "",
-        ]
-
-        if (unit.prerequisites?.length > 0) {
-          lines.push("**Prerequisites:**")
-          for (const p of unit.prerequisites) lines.push(`- ${p.name} (${p.minLevel})`)
-          lines.push("")
-        }
-
-        if (unit.simpleExplanation) {
-          lines.push("**Simple explanation:**", unit.simpleExplanation, "")
-        }
-
-        if (unit.technicalExplanation) {
-          lines.push("**Technical explanation:**", unit.technicalExplanation, "")
-        }
-
-        if (unit.minimalExample) {
-          lines.push("**Minimal example:**", "```", unit.minimalExample, "```", "")
-        }
-
-        if (unit.relationships?.length > 0) {
-          lines.push("**Relationships:**")
-          for (const r of unit.relationships) lines.push(`- ${r.concept}: ${r.relation}`)
-          lines.push("")
-        }
-
-        if (unit.commonErrors?.length > 0) {
-          lines.push("**Common errors:**")
-          for (const e of unit.commonErrors) lines.push(`- ⚠ ${e.symptom} → ${e.fix}`)
-          lines.push("")
-        }
-
-        try {
-          const allErrors = scanForLearnErrors(process.cwd())
-          const projectErrors = allErrors.filter(
-            (e) =>
-              e.id.toLowerCase().includes(conceptId.toLowerCase()) ||
-              (e.category && e.category.toLowerCase() === conceptId.toLowerCase())
-          )
-          if (projectErrors.length > 0) {
-            lines.push("**Project Learned Errors (@learn-error):**")
-            for (const e of projectErrors) lines.push(`- ⚠ ${e.id}: ${e.problem} → ${e.solution}`)
-            lines.push("")
-          }
-        } catch (err) {
-          // Ignore scanning errors silently
-        }
-
-        if (includeExercises) {
-          let exercise
-          if (getLevel(userLevel).index <= 3) {
-            exercise = generateGuidedExercise(conceptId)
-          } else {
-            exercise = generateFreeExercise(conceptId)
-          }
-          lines.push("**Exercise:**", exercise.prompt, "")
-          if (exercise.steps) lines.push("Steps:", ...exercise.steps.map((s) => `- ${s}`))
-          if (exercise.hints) lines.push("Hints:", ...exercise.hints.map((h) => `- ${h}`))
-          if (exercise.criteria) lines.push("Criteria:", ...exercise.criteria.map((c) => `- ${c}`))
-          lines.push("")
-        }
-
-        if (unit.masteryCriteria?.length > 0) {
-          lines.push("**Mastery criteria:**")
-          for (const c of unit.masteryCriteria) lines.push(`- ${c}`)
-        }
-
-        return toolResult(lines.join("\n"))
-      } catch (err) {
-        return toolResult(`Concept not found: "${conceptId}". Register it first.`, true)
-      }
-    }
-
-    default:
-      return toolResult(`Unknown tool: ${name}`, true)
-  }
-}
-
-export function startServer() {
-  // PID lock: evitar servidores duplicados
-  const PID_PATH = join(process.cwd(), ".opencode", "mcp.pid")
-  try {
-    if (existsSync(PID_PATH)) {
-      const oldPid = readFileSync(PID_PATH, "utf-8").trim()
-      try {
-        process.kill(parseInt(oldPid), 0)
-        console.error(`[mcp] ⚠ Ya hay un servidor MCP activo (PID ${oldPid}). Saliendo.`)
-        process.exit(1)
-      } catch {
-        /* PID huérfano, continuar */
-      }
-    }
-    mkdirSync(dirname(PID_PATH), { recursive: true })
-    writeFileSync(PID_PATH, String(process.pid))
-  } catch {
-    /* fallback: continuar sin PID lock */
-  }
-
-  // Graceful shutdown: limpiar PID file y conexiones
-  function cleanupAndExit() {
-    try {
-      if (existsSync(PID_PATH)) rmSync(PID_PATH)
-    } catch {
-      /* ignore */
-    }
-    try {
-      import("./persistence/sqlite/connection.js").then((m) => m.close())
-    } catch {
-      /* ignore */
-    }
-    process.exit(0)
-  }
-  process.on("SIGTERM", cleanupAndExit)
-  process.on("SIGINT", cleanupAndExit)
-
-  let buffer = ""
-
-  process.stdin.setEncoding("utf-8")
-  process.stdin.on("data", async (chunk) => {
-    buffer += chunk
-    const lines = buffer.split("\n")
-    buffer = lines.pop() || ""
-
-    for (const line of lines) {
-      const trimmed = line.trim()
-      if (!trimmed) continue
-
-      let msg
-      try {
-        msg = JSON.parse(trimmed)
-      } catch {
-        continue
-      }
-
-      if (msg.jsonrpc !== "2.0") continue
-
-      const { id, method, params } = msg
-
-      const isNotification = id === undefined || id === null
-
-      switch (method) {
-        case "initialize": {
-          const clientVersion = params?.protocolVersion
-          const clientSupportsLatest =
-            clientVersion && SUPPORTED_PROTOCOL_VERSIONS.includes(clientVersion)
-          const negotiatedVersion = clientSupportsLatest ? clientVersion : LATEST_PROTOCOL_VERSION
-
-          // Generate rich dynamic instructions based on project context
-          const instructions = generateRichInstructions()
-
-          sendResult(id, {
-            protocolVersion: negotiatedVersion,
-            capabilities: {
-              tools: { listChanged: false },
-              logging: {},
-            },
-            serverInfo: SERVER_INFO,
-            instructions,
-          })
-          break
-        }
-
-        case "notifications/initialized": {
-          // Per MCP spec: client MUST send this notification after initialize response.
-          // No response is sent for notifications (they have no id).
-          break
-        }
-
-        case "tools/list": {
-          sendResult(id, { tools: TOOLS })
-          break
-        }
-
-        case "tools/call": {
-          try {
-            const toolName = params.name
-            const toolArgs = params.arguments
-
-            // Load session and check preconditions
-            const session = getSessionState()
-            const precondition = checkPreconditions(toolName, process.cwd())
-
-            if (!precondition.allowed) {
-              // Strict mode: block execution
-              sendResult(
-                id,
-                prepareToolResponse(
-                  toolResult(`Workflow bloqueado: ${precondition.reason}`, true),
-                  precondition
-                )
-              )
-              return
-            }
-
-            // Execute the tool
-            const result = await handleToolCall(toolName, toolArgs)
-
-            // Handle guide-level warnings (soft enforcement)
-            let finalResult = result
-            if (precondition.reason) {
-              finalResult = prepareToolResponse(result, precondition)
-            }
-
-            // Update session state
-            recordToolCall(session, toolName)
-            if (toolName === "validate" || toolName === "lint_file") markValidated(session)
-            if (
-              toolName === "context_unified" ||
-              toolName === "knowledge_search" ||
-              toolName === "recall"
-            ) {
-              setPhase(session, "researching")
-            }
-            saveSessionState(session)
-
-            // Check for auto-ticket on friction
-            if (shouldAutoTicket(session, finalResult)) {
-              const frictionNote = `\n\n---\n📋 **Fricción detectada:** Has encontrado errores después de omitir pasos del workflow. Considera crear un ticket para mejorar el sistema: \`ticket create --title "Fricción en workflow: ${toolName}" --domain ${session.active_domain?.[0] || "programming"}\``
-              finalResult = {
-                ...finalResult,
-                content: [{ type: "text", text: finalResult.content[0].text + frictionNote }],
-              }
-            }
-
-            sendResult(id, finalResult)
-          } catch (err) {
-            sendError(id, -1, err.message)
-          }
-          break
-        }
-
-        case "shutdown": {
-          sendResult(id, null)
-          process.exitCode = 0
-          try {
-            if (existsSync(PID_PATH)) rmSync(PID_PATH)
-          } catch {
-            /* ignore */
-          }
-          process.stdout.once("drain", () => process.exit(0))
-          setTimeout(() => process.exit(0), 1000).unref()
-          break
-        }
-
-        default:
-          if (!isNotification) {
-            sendError(id, -32601, `Method not found: ${method}`)
-          }
-      }
-    }
-  })
-
-  process.stdin.on("end", () => process.exit(0))
-}
-
-// Auto-start when executed directly, not when imported
-const isDirectRun =
-  process.argv[1] &&
-  (process.argv[1].endsWith("mcp-server.js") || process.argv[1].endsWith("mcp-server"))
-if (isDirectRun) startServer()