specatlas 0.1.24 → 0.1.25

package/dist/bin.js

@@ -1585,7 +1585,7 @@ var require_core = __commonJS({
 });
 
 // src/cli.ts
-import path39 from "path";
+import path41 from "path";
 
 // ../core/dist/index.js
 import path from "path";
@@ -9593,6 +9593,146 @@ function findScenarioHeading(lines, blockLineIndex) {
   }
   return void 0;
 }
+var HEADER_KEYS = /* @__PURE__ */ new Set(["t\xE9rmino", "termino", "term", "definici\xF3n", "definicion", "definition", "sin\xF3nimos", "sinonimos", "synonyms"]);
+var SEPARATOR_RE = /^:?-{2,}:?$/;
+function parseGlossary(md, filePath) {
+  const diagnostics = [];
+  const terms = [];
+  const lines = md.replace(/\r\n?/g, "\n").split("\n");
+  for (let i = 0; i < lines.length; i += 1) {
+    const raw = lines[i] ?? "";
+    if (!raw.trim().startsWith("|")) continue;
+    const inner = raw.trim().replace(/^\|/, "").replace(/\|$/, "");
+    const cells = inner.split("|").map((c) => c.trim());
+    if (cells.length < 2) {
+      diagnostics.push(diag("LINT-GLO-001", "warning", "Fila del glosario sin columnas suficientes", { path: filePath, line: i + 1 }));
+      continue;
+    }
+    const first = cells[0] ?? "";
+    if (HEADER_KEYS.has(first.toLowerCase()) || SEPARATOR_RE.test(first)) continue;
+    const term = first;
+    const definition = cells[1] ?? "";
+    if (term === "" || definition === "") {
+      diagnostics.push(diag("LINT-GLO-002", "warning", "T\xE9rmino o definici\xF3n vac\xEDos en el glosario", { path: filePath, line: i + 1 }));
+      continue;
+    }
+    const synonyms = (cells[2] ?? "").split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    terms.push({ term, definition, synonyms });
+  }
+  return { terms, diagnostics };
+}
+function normalizePath(p) {
+  return toPosix(p.trim()).replace(/^\.\//, "").replace(/\/+$/, "").toLowerCase();
+}
+function fileMatches(query, candidate) {
+  if (query === candidate) return true;
+  return candidate.endsWith(`/${query}`);
+}
+function scenarioToReq(workspace) {
+  const map = /* @__PURE__ */ new Map();
+  for (const spec of workspace.specs) {
+    for (const req of spec.spec.requirements) {
+      for (const sc of req.scenarios) map.set(sc.id, req.id);
+    }
+  }
+  for (const change of workspace.changes) {
+    for (const req of [...change.delta?.added ?? [], ...change.delta?.modified ?? []]) {
+      for (const sc of req.scenarios) map.set(sc.id, req.id);
+    }
+  }
+  return map;
+}
+function emptyReport(target, kind) {
+  return { target, kind, exists: false, scenarios: [], tasks: [], requirements: [], changes: [], files: [], evidence: [] };
+}
+function collect(workspace, report, covers, reqOf) {
+  const requirements = /* @__PURE__ */ new Set();
+  for (const change of workspace.changes) {
+    let changeMatches = false;
+    for (const block of change.tasks?.blocks ?? []) {
+      for (const task of block.tasks) {
+        const hit = task.covers.some((c) => covers.has(c.toUpperCase()));
+        if (!hit) continue;
+        changeMatches = true;
+        report.tasks.push({ id: task.id, change: change.slug, text: task.text, files: task.files, covers: task.covers });
+        for (const c of task.covers) {
+          const upper = c.toUpperCase();
+          if (covers.has(upper)) {
+            const req = reqOf.get(upper) ?? upper;
+            requirements.add(req);
+          }
+        }
+        for (const f of task.files) report.files.push(f);
+      }
+    }
+    if (changeMatches) report.changes.push(change.slug);
+    for (const ev of change.verify?.evidence ?? []) {
+      if (covers.has(ev.scenario.toUpperCase())) {
+        report.evidence.push({ scenario: ev.scenario, result: ev.result, change: change.slug });
+      }
+    }
+  }
+  report.requirements = [...requirements].sort();
+  report.changes = [...new Set(report.changes)].sort();
+  report.files = [...new Set(report.files)].sort();
+  report.evidence.sort((a, b) => a.scenario.localeCompare(b.scenario));
+}
+function impactOfRequirement(workspace, reqId) {
+  const id = reqId.toUpperCase();
+  const scenarios = /* @__PURE__ */ new Set();
+  let exists2 = false;
+  for (const spec of workspace.specs) {
+    for (const req of spec.spec.requirements) {
+      if (req.id !== id) continue;
+      exists2 = true;
+      for (const sc of req.scenarios) scenarios.add(sc.id);
+    }
+  }
+  for (const change of workspace.changes) {
+    for (const req of [...change.delta?.added ?? [], ...change.delta?.modified ?? []]) {
+      if (req.id !== id) continue;
+      exists2 = true;
+      for (const sc of req.scenarios) scenarios.add(sc.id);
+    }
+    if ((change.delta?.removed ?? []).some((r) => r.id === id)) exists2 = true;
+    if ((change.delta?.renamed ?? []).some((r) => r.from.id === id || r.to.id === id)) exists2 = true;
+  }
+  const report = emptyReport(id, "requirement");
+  if (!exists2) return report;
+  report.exists = true;
+  report.scenarios = [...scenarios].sort();
+  const reqOf = scenarioToReq(workspace);
+  collect(workspace, report, /* @__PURE__ */ new Set([id, ...scenarios]), reqOf);
+  if (!report.requirements.includes(id)) report.requirements.unshift(id);
+  return report;
+}
+function impactOfFile(workspace, file) {
+  const query = normalizePath(file);
+  const report = emptyReport(file, "file");
+  const covers = /* @__PURE__ */ new Set();
+  const matched = /* @__PURE__ */ new Set();
+  const changes = /* @__PURE__ */ new Set();
+  for (const change of workspace.changes) {
+    for (const block of change.tasks?.blocks ?? []) {
+      for (const task of block.tasks) {
+        if (!task.files.some((f) => fileMatches(query, normalizePath(f)))) continue;
+        changes.add(change.slug);
+        for (const f of task.files) matched.add(f);
+        for (const c of task.covers) covers.add(c.toUpperCase());
+        report.tasks.push({ id: task.id, change: change.slug, text: task.text, files: task.files, covers: task.covers });
+      }
+    }
+  }
+  if (matched.size === 0) return report;
+  report.exists = true;
+  report.files = [...matched].sort();
+  report.changes = [...changes].sort();
+  const reqOf = scenarioToReq(workspace);
+  const requirements = /* @__PURE__ */ new Set();
+  for (const c of covers) requirements.add(reqOf.get(c) ?? c);
+  report.requirements = [...requirements].sort();
+  return report;
+}
 var VAGUE_ES = ["r\xE1pido", "r\xE1pida", "r\xE1pidos", "r\xE1pidas", "f\xE1cil", "f\xE1ciles", "varios", "varias", "\xF3ptimo", "\xF3ptima", "robusto", "robusta", "adecuado", "adecuada", "eficiente", "amigable", "moderno", "moderna", "mejor", "mejores", "simple", "sencillo", "intuitivo", "intuitiva", "apropiado", "apropiada", "suficiente", "razonable"];
 var VAGUE_EN = ["fast", "quick", "easy", "several", "optimal", "robust", "adequate", "efficient", "friendly", "modern", "better", "best", "simple", "intuitive", "appropriate", "sufficient", "reasonable", "nice", "clean"];
 var TECH_ES = ["api", "endpoint", "tabla", "base de datos", "sql", "json", "xml", "frontend", "backend", "react", "vue", "angular", "node", "npm", "docker", "kubernetes", "servidor", "columna", "query", "script", "framework", "librer\xEDa", "microservicio", "cache", "cach\xE9", "deploy", "despliegue", "commit", "merge", "rama", "branch", "endpoint", "crud", "rest", "http", "sdk", "webhook", "orm", "job", "cron", "websocket", "graphql", "api rest", "tablas", "\xEDndice", "primary key", "foreign key"];
@@ -10055,6 +10195,17 @@ function deriveState(input) {
   }
   if (blockingFindings > 0) {
     blockedBy.push(`${blockingFindings} hallazgo(s) bloqueante(s)`);
+    if (tasksTotal > 0 && tasksDone < tasksTotal) {
+      return {
+        state: "building",
+        blockedBy,
+        nextAction: next(`/satlas.build ${change.slug}`, `Construir en olas (${tasksDone}/${tasksTotal} tareas) \xB7 ${blockingFindings} hallazgo(s) pendientes`, true),
+        progress
+      };
+    }
+    if (tasksTotal > 0) {
+      return { state: "built", blockedBy, nextAction: next(`satlas verify ${change.slug}`, "Registrar evidencia por escenario"), progress };
+    }
     return { state: "spec_draft", blockedBy, nextAction: next(`satlas validate --change ${change.slug}`, "Corregir los hallazgos de la especificaci\xF3n"), progress };
   }
   if ((approval.status === "missing" || approval.status === "stale") && requiresMockups(change.meta, cfg) && input.mockupsReady !== true && !mockupOverride(change)) {
@@ -13029,6 +13180,7 @@ var CATALOG = [
   { name: "mockup", description: "Planifica, valida o captura los mockups del cambio", flags: ["plan", "check", "capture", "require", "json"], usage: "satlas mockup <slug> [--plan|--check|--capture|--require]" },
   { name: "present", description: "Genera el paquete de propuesta para el stakeholder (HTML autocontenido)", flags: ["json"], usage: "satlas present <slug>" },
   { name: "ci", description: "Gate de pipeline: specs + cambios + doctor + adaptadores (sin agente)", flags: ["strict", "json"], usage: "satlas ci [--strict]" },
+  { name: "mcp", description: "V\xEDa de consulta de solo lectura para asistentes (protocolo MCP sobre entrada/salida est\xE1ndar)", flags: [], usage: "satlas mcp" },
   { name: "metrics", description: "M\xE9tricas locales del workspace (progreso, WIP, throughput, evidencia)", flags: ["json"], usage: "satlas metrics [--json]" },
   { name: "run", description: "Persiste runs y eventos de ejecuci\xF3n (auditor\xEDa y reanudaci\xF3n)", flags: ["phase", "inputs", "data", "slug", "status", "json"], usage: "satlas run start|event|status|show|list" },
   { name: "hash", description: "Calcula el sha256 de un archivo o texto (para evidencia)", flags: ["text", "json"], usage: 'satlas hash <archivo> | satlas hash --text "salida"' },
@@ -14206,8 +14358,504 @@ async function runMockup(ctx) {
   return { exitCode: 0, diagnostics: [], data: { plan, planFile: path31.relative(ctx.cwd, planFile), manifestFile: path31.relative(ctx.cwd, manifestFile) }, text: lines };
 }
 
-// src/commands/packs.ts
+// src/mcp/server.ts
+import { promises as fs2 } from "fs";
+import path34 from "path";
+import { createInterface } from "readline/promises";
+
+// src/mcp/protocol.ts
+var JSONRPC_VERSION = "2.0";
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var METHOD_NOT_FOUND = -32601;
+var INTERNAL_ERROR = -32603;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function makeResult(id, result) {
+  return { jsonrpc: JSONRPC_VERSION, id, result };
+}
+function makeError(id, code, message, data) {
+  const error = { code, message };
+  if (data !== void 0) error.data = data;
+  return { jsonrpc: JSONRPC_VERSION, id, error };
+}
+function parseMessage(line) {
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return { error: { code: PARSE_ERROR, message: "El mensaje no es JSON v\xE1lido" } };
+  }
+  if (!isObject(value) || value["jsonrpc"] !== JSONRPC_VERSION) {
+    return { error: { code: INVALID_REQUEST, message: "Mensaje no es una petici\xF3n JSON-RPC 2.0 v\xE1lida" } };
+  }
+  if (typeof value["method"] !== "string") {
+    return { error: { code: INVALID_REQUEST, message: "El mensaje no declara un m\xE9todo" } };
+  }
+  const idValue = value["id"] ?? null;
+  const id = typeof idValue === "number" || typeof idValue === "string" || idValue === null ? idValue : null;
+  const request = { jsonrpc: JSONRPC_VERSION, id, method: value["method"] };
+  if (value["params"] !== void 0) request.params = value["params"];
+  return { request };
+}
+function jsonResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(code, message, extra) {
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify({ error: code, message, ...extra }, null, 2) }]
+  };
+}
+function noWorkspaceResult() {
+  return errorResult(
+    "ATLAS-MCP-WS-001",
+    "El proyecto no est\xE1 inicializado: no se encontr\xF3 el estado del proyecto en esta carpeta.",
+    { action: "satlas init" }
+  );
+}
+function stringArg(args, key) {
+  if (!isObject(args)) return void 0;
+  const value = args[key];
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+
+// src/mcp/tools/glossary.ts
 import path32 from "path";
+async function runAtlasGlossary(_args, host) {
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { root, config } = resolved;
+  const glossaryPath = path32.resolve(root, config.spec.glossary);
+  const raw = await readTextIfExists(glossaryPath);
+  if (raw === void 0) {
+    return jsonResult({
+      terms: [],
+      message: "El glosario no tiene t\xE9rminos definidos.",
+      action: "Define los t\xE9rminos del negocio en el glosario del proyecto."
+    });
+  }
+  const parsed = parseGlossary(raw, glossaryPath);
+  if (parsed.terms.length === 0) {
+    return jsonResult({
+      terms: [],
+      message: "El glosario no tiene t\xE9rminos definidos.",
+      action: "Define los t\xE9rminos del negocio en el glosario del proyecto."
+    });
+  }
+  return jsonResult({ terms: parsed.terms });
+}
+
+// src/mcp/tools/impact.ts
+var REQ_TARGET_RE = /^REQ-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}(?:-S\d+)?$/i;
+async function runAtlasImpact(args, host) {
+  const target = stringArg(args, "target");
+  if (!target) {
+    return errorResult("ATLAS-MCP-IMPACT-001", "Falta el requisito o el archivo a consultar", {
+      action: "atlas_impact con el argumento target (REQ-\u2026 o ruta de archivo)"
+    });
+  }
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { workspace } = resolved;
+  let report;
+  if (REQ_TARGET_RE.test(target)) {
+    const reqId = target.toUpperCase().replace(/-S\d+$/, "");
+    report = impactOfRequirement(workspace, reqId);
+  } else {
+    report = impactOfFile(workspace, target);
+  }
+  if (!report.exists) {
+    return jsonResult({ target, exists: false, message: `Sin relaciones registradas para "${target}".` });
+  }
+  return jsonResult(report);
+}
+
+// src/evaluate.ts
+import path33 from "path";
+function livingRequirementsMap2(specs) {
+  const map = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    for (const req of spec.spec.requirements) map.set(req.id, req);
+  }
+  return map;
+}
+async function evaluateChange(workspace, config, change, approvals) {
+  const deltaPath = path33.join(change.dir, "spec.md");
+  const deltaContent = await readTextIfExists(deltaPath);
+  const approval = verifyApproval(change, approvals, config, deltaContent ?? void 0);
+  const living = livingRequirementsMap2(workspace.specs);
+  const lintFindings = change.delta ? lintDelta(change.delta, living, deltaPath, { language: config.spec.language }) : [];
+  const trace = checkTrace({
+    specs: workspace.specs,
+    change,
+    requireEvidence: config.gates.verify.mode !== "off" && config.gates.verify.require_evidence
+  });
+  const blocking = lintFindings.filter((d) => d.severity === "error").length + trace.findings.filter((d) => d.severity === "error").length;
+  const mockupsAreReady = requiresMockups(change.meta, config) ? await mockupsReady(workspace.root, change.slug, change) : void 0;
+  const state = deriveState({
+    change,
+    cfg: config,
+    approval,
+    blockingFindings: change.delta ? blocking : 0,
+    ...mockupsAreReady !== void 0 ? { mockupsReady: mockupsAreReady } : {}
+  });
+  return { change, approval, lintFindings, trace, blocking, state };
+}
+
+// src/mcp/tools/next.ts
+var HUMAN_COMMANDS = [/^satlas approve/, /^satlas archive/, /^satlas resume/, /^satlas present/];
+function requiresPerson(nextCommand, state) {
+  if (state === "awaiting_approval" || state === "ready") return true;
+  return HUMAN_COMMANDS.some((re) => re.test(nextCommand));
+}
+async function runAtlasNext(args, host) {
+  const slug = stringArg(args, "slug");
+  if (!slug) {
+    return errorResult("ATLAS-MCP-NEXT-001", "Falta el nombre del cambio", { action: "atlas_next con el argumento slug" });
+  }
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { workspace, config, approvals } = resolved;
+  const change = workspace.changes.find((c) => c.slug === slug);
+  if (!change) {
+    return errorResult("ATLAS-MCP-NEXT-002", `El cambio "${slug}" no existe`, {
+      available: workspace.changes.map((c) => c.slug)
+    });
+  }
+  const evaluation = await evaluateChange(workspace, config, change, approvals);
+  const { state, nextAction, blockedBy } = evaluation.state;
+  const humanRequired = requiresPerson(nextAction.command, state);
+  return jsonResult({
+    slug,
+    state,
+    label: stateLabel(state),
+    next: { command: nextAction.command, description: nextAction.description, requiresAgent: nextAction.requiresAgent },
+    requiresPerson: humanRequired,
+    blockedBy
+  });
+}
+
+// src/mcp/tools/status.ts
+async function runAtlasStatus(args, host) {
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { workspace, config, approvals } = resolved;
+  const slug = stringArg(args, "slug");
+  if (slug && !workspace.changes.some((c) => c.slug === slug)) {
+    return errorResult("ATLAS-MCP-STATUS-001", `El cambio "${slug}" no existe`, {
+      available: workspace.changes.map((c) => c.slug)
+    });
+  }
+  const changes = [];
+  for (const change of workspace.changes) {
+    if (slug && change.slug !== slug) continue;
+    const evaluation = await evaluateChange(workspace, config, change, approvals);
+    const { state, progress, nextAction, blockedBy } = evaluation.state;
+    changes.push({
+      slug: change.slug,
+      lane: change.meta?.lane ?? config.lanes.default,
+      domain: change.meta?.domain,
+      state,
+      label: stateLabel(state),
+      progress,
+      blocking: evaluation.blocking,
+      blockedBy,
+      next: { command: nextAction.command, description: nextAction.description, requiresAgent: nextAction.requiresAgent }
+    });
+  }
+  if (changes.length === 0) {
+    return jsonResult({
+      changes: [],
+      specs: workspace.specs.map((s) => ({ domain: s.domain, requirements: s.spec.requirements.length })),
+      message: "Sin cambios activos.",
+      action: "satlas new <slug>"
+    });
+  }
+  return jsonResult({
+    changes,
+    specs: workspace.specs.map((s) => ({ domain: s.domain, requirements: s.spec.requirements.length }))
+  });
+}
+
+// src/mcp/tools/trace.ts
+async function runAtlasTrace(args, host) {
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { workspace } = resolved;
+  const slug = stringArg(args, "slug");
+  const changes = slug ? workspace.changes.filter((c) => c.slug === slug) : workspace.changes;
+  const result = [];
+  for (const change of changes) {
+    const trace = checkTrace({ specs: workspace.specs, change, requireEvidence: false });
+    const coversByTask = /* @__PURE__ */ new Map();
+    for (const block of change.tasks?.blocks ?? []) {
+      for (const task of block.tasks) coversByTask.set(task.id, task.covers.map((c) => c.toUpperCase()));
+    }
+    const evidenceByScenario = /* @__PURE__ */ new Map();
+    for (const ev of change.verify?.evidence ?? []) {
+      const known = evidenceByScenario.get(ev.scenario);
+      if (known === void 0 || ev.result === "pass") evidenceByScenario.set(ev.scenario, ev.result);
+    }
+    const scenarios = [];
+    for (const req of [...change.delta?.added ?? [], ...change.delta?.modified ?? []]) {
+      for (const sc of req.scenarios) {
+        const parent = sc.reqId.toUpperCase();
+        const coveredBy = [...coversByTask.entries()].filter(([, covers]) => covers.includes(sc.id.toUpperCase()) || covers.includes(parent)).map(([taskId]) => taskId);
+        const evidence = evidenceByScenario.get(sc.id) ?? null;
+        scenarios.push({ id: sc.id, title: sc.title, coveredBy, evidence });
+      }
+    }
+    const gaps = trace.findings.filter((f) => f.code === "TRACE-002").map((f) => String(f.target ?? f.message));
+    result.push({ slug: change.slug, scenarios, gaps, summary: { errors: trace.summary.errors, warnings: trace.summary.warnings } });
+  }
+  if (changes.length === 0) {
+    return jsonResult({ changes: [], message: "Sin cambios activos.", action: "satlas new <slug>" });
+  }
+  return jsonResult({ changes: result });
+}
+
+// src/mcp/tools/validate.ts
+async function runAtlasValidate(args, host) {
+  const slug = stringArg(args, "slug");
+  if (!slug) {
+    return errorResult("ATLAS-MCP-VALIDATE-001", "Falta el nombre del cambio", { action: "atlas_validate con el argumento slug" });
+  }
+  const resolved = await host.getWorkspace();
+  if (!resolved) return noWorkspaceResult();
+  const { workspace, config, approvals } = resolved;
+  const change = workspace.changes.find((c) => c.slug === slug);
+  if (!change) {
+    return errorResult("ATLAS-MCP-VALIDATE-002", `El cambio "${slug}" no existe`, {
+      available: workspace.changes.map((c) => c.slug)
+    });
+  }
+  const evaluation = await evaluateChange(workspace, config, change, approvals);
+  const findings = [...evaluation.lintFindings, ...evaluation.trace.findings].map((d) => ({
+    code: d.code,
+    severity: d.severity,
+    message: d.message,
+    path: d.path,
+    line: d.line,
+    suggestion: d.suggestion
+  }));
+  if (findings.length === 0) {
+    return jsonResult({ slug, conforming: true, message: "Sin hallazgos: el cambio est\xE1 conforme.", findings: [] });
+  }
+  return jsonResult({
+    slug,
+    conforming: findings.every((f) => f.severity !== "error"),
+    findings,
+    summary: evaluation.trace.summary
+  });
+}
+
+// src/mcp/tools/index.ts
+var HANDLERS = {
+  atlas_status: runAtlasStatus,
+  atlas_next: runAtlasNext,
+  atlas_validate: runAtlasValidate,
+  atlas_trace: runAtlasTrace,
+  atlas_impact: runAtlasImpact,
+  atlas_glossary: runAtlasGlossary
+};
+async function runToolByName(name, args, host) {
+  const handler = HANDLERS[name];
+  if (!handler) {
+    return errorResult("ATLAS-MCP-TOOL-002", `Operaci\xF3n desconocida: ${name}`, { available: Object.keys(HANDLERS).sort() });
+  }
+  return handler(args, host);
+}
+
+// src/mcp/tools/list.ts
+function listTools() {
+  return [
+    {
+      name: "atlas_status",
+      description: "Estado del proyecto: cambios activos con fase, avance de tareas y evidencia, bloqueos y siguiente paso. Opcional: nombre de un cambio.",
+      inputSchema: {
+        type: "object",
+        properties: { slug: { type: "string", description: "Nombre del cambio (opcional): si se indica, solo se informa de ese cambio" } },
+        additionalProperties: false
+      }
+    },
+    {
+      name: "atlas_next",
+      description: "Siguiente acci\xF3n recomendada para un cambio, con la indicaci\xF3n de si requiere una persona o la puede realizar el asistente.",
+      inputSchema: {
+        type: "object",
+        properties: { slug: { type: "string", description: "Nombre del cambio" } },
+        required: ["slug"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "atlas_validate",
+      description: "Hallazgos vigentes de un cambio (validaci\xF3n y trazabilidad), id\xE9nticos a los que reporta la herramienta. Nunca modifica nada.",
+      inputSchema: {
+        type: "object",
+        properties: { slug: { type: "string", description: "Nombre del cambio" } },
+        required: ["slug"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "atlas_trace",
+      description: "Cobertura de trazabilidad: por escenario, qu\xE9 tarea lo cubre y su evidencia, y los huecos vigentes.",
+      inputSchema: {
+        type: "object",
+        properties: { slug: { type: "string", description: "Nombre del cambio (opcional)" } },
+        additionalProperties: false
+      }
+    },
+    {
+      name: "atlas_impact",
+      description: "Impacto registrado de un requisito (REQ-\u2026) o de un archivo: escenarios, tareas, cambios, archivos y evidencia relacionados. Solo relaciones registradas.",
+      inputSchema: {
+        type: "object",
+        properties: { target: { type: "string", description: "Id de requisito (por ejemplo REQ-AUTH-001) o ruta de archivo" } },
+        required: ["target"],
+        additionalProperties: false
+      }
+    },
+    {
+      name: "atlas_glossary",
+      description: "T\xE9rminos del glosario del negocio con su definici\xF3n vigente y sin\xF3nimos aceptados. No inventa definiciones.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      }
+    }
+  ];
+}
+
+// src/mcp/server.ts
+var PROTOCOL_VERSION = "2024-11-05";
+var SERVER_NAME = "specatlas";
+var WorkspaceCache = class {
+  entries = /* @__PURE__ */ new Map();
+  get(root) {
+    return this.entries.get(root);
+  }
+  set(root, mtimeMs, value) {
+    this.entries.set(root, { mtimeMs, value });
+  }
+};
+async function workspaceStamp(root) {
+  const sddDir = path34.join(root, ".sdd");
+  const markers = [sddDir, path34.join(sddDir, "config.yaml"), path34.join(sddDir, "changes"), path34.join(sddDir, "specs"), path34.join(sddDir, "approvals.yaml")];
+  let stamp = 0;
+  for (const marker of markers) {
+    try {
+      const st = await fs2.stat(marker);
+      stamp = Math.max(stamp, st.mtimeMs);
+    } catch {
+    }
+  }
+  return stamp;
+}
+async function resolveMcpWorkspace(cwd, cache) {
+  const root = await findWorkspaceRoot(cwd);
+  if (!root) return void 0;
+  const stamp = await workspaceStamp(root);
+  const cached2 = cache.get(root);
+  if (cached2 && cached2.mtimeMs === stamp) return cached2.value;
+  const { workspace, config } = await loadWorkspace(root);
+  const approvals = await loadApprovals(path34.join(root, ".sdd"));
+  const value = { root, workspace, config, approvals: approvals.byArtifact };
+  cache.set(root, stamp, value);
+  return value;
+}
+function createHost(cwd, cache) {
+  return {
+    cwd,
+    language: "es",
+    getWorkspace: () => resolveMcpWorkspace(cwd, cache)
+  };
+}
+async function handleRequest(req, host) {
+  const id = req.id;
+  if (req.method === "initialize") {
+    return makeResult(id, {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: { tools: { listChanged: false } },
+      serverInfo: { name: SERVER_NAME, version: cliVersion() }
+    });
+  }
+  if (req.method === "ping") {
+    return makeResult(id, {});
+  }
+  if (req.method === "tools/list") {
+    return makeResult(id, { tools: listTools() });
+  }
+  if (req.method === "tools/call") {
+    const params = isObject(req.params) ? req.params : {};
+    const name = typeof params["name"] === "string" ? params["name"] : "";
+    if (name === "") {
+      return makeResult(id, {
+        content: [{ type: "text", text: JSON.stringify({ error: "ATLAS-MCP-TOOL-001", message: "Falta el nombre de la operaci\xF3n" }, null, 2) }],
+        isError: true
+      });
+    }
+    try {
+      const result = await runToolByName(name, params["arguments"], host);
+      return makeResult(id, result);
+    } catch (err) {
+      return makeError(id, INTERNAL_ERROR, "Error interno al ejecutar la operaci\xF3n", { message: err instanceof Error ? err.message : String(err) });
+    }
+  }
+  if (req.method.startsWith("notifications/")) {
+    return void 0;
+  }
+  return makeError(id, METHOD_NOT_FOUND, `M\xE9todo desconocido: ${req.method}`);
+}
+function log(stderr, message) {
+  stderr.write(`[specatlas mcp] ${message}
+`);
+}
+async function runMcpServer(opts) {
+  const { cwd, stdin, stdout, stderr } = opts;
+  const cache = new WorkspaceCache();
+  const host = createHost(cwd, cache);
+  log(stderr, "v\xEDa de consulta iniciada (solo lectura)");
+  const rl = createInterface({ input: stdin, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (line.trim() === "") continue;
+    const parsed = parseMessage(line);
+    if (parsed.error) {
+      const response = makeError(null, parsed.error.code, parsed.error.message);
+      stdout.write(`${JSON.stringify(response)}
+`);
+      continue;
+    }
+    const request = parsed.request;
+    try {
+      const response = await handleRequest(request, host);
+      if (response) stdout.write(`${JSON.stringify(response)}
+`);
+    } catch (err) {
+      log(stderr, err instanceof Error ? err.message : String(err));
+      stdout.write(`${JSON.stringify(makeError(request.id, INTERNAL_ERROR, "Error interno"))}
+`);
+    }
+  }
+}
+
+// src/commands/mcp.ts
+async function runMcp(ctx) {
+  await runMcpServer({
+    cwd: ctx.cwd,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr
+  });
+  return { exitCode: 0, diagnostics: [], data: { served: true } };
+}
+
+// src/commands/packs.ts
+import path35 from "path";
 async function runPacks(ctx) {
   const { root, config, workspace } = await requireWorkspace(ctx);
   const slug = flagString(ctx.flags, "check");
@@ -14265,14 +14913,14 @@ async function runPacks(ctx) {
     data: {
       slug,
       packs: evaluations.map((evaluation) => ({ id: evaluation.pack.id, status: evaluation.status, passed: evaluation.passed, failed: evaluation.failed, results: evaluation.results })),
-      analyzePath: path32.posix.join(".sdd", "changes", slug, "analyze.md")
+      analyzePath: path35.posix.join(".sdd", "changes", slug, "analyze.md")
     },
     text: lines
   };
 }
 
 // src/commands/new.ts
-import path33 from "path";
+import path36 from "path";
 async function runNew(ctx) {
   const slug = ctx.positionals[0];
   if (!slug) {
@@ -14298,50 +14946,18 @@ async function runNew(ctx) {
     msg("new.title", ctx.language),
     "",
     msg("new.done", ctx.language),
-    ...result.files.map((f) => `  + ${path33.relative(ctx.cwd, f)}`),
+    ...result.files.map((f) => `  + ${path36.relative(ctx.cwd, f)}`),
     "",
     `Siguiente: /satlas.specify ${result.slug} \u2014 escribe la especificaci\xF3n 100% funcional y de negocio.`
   ];
   return {
     exitCode: hasErrors2 ? 1 : 0,
     diagnostics: result.diagnostics,
-    data: { slug: result.slug, files: result.files.map((f) => path33.relative(ctx.cwd, f)) },
+    data: { slug: result.slug, files: result.files.map((f) => path36.relative(ctx.cwd, f)) },
     text: lines
   };
 }
 
-// src/evaluate.ts
-import path34 from "path";
-function livingRequirementsMap2(specs) {
-  const map = /* @__PURE__ */ new Map();
-  for (const spec of specs) {
-    for (const req of spec.spec.requirements) map.set(req.id, req);
-  }
-  return map;
-}
-async function evaluateChange(workspace, config, change, approvals) {
-  const deltaPath = path34.join(change.dir, "spec.md");
-  const deltaContent = await readTextIfExists(deltaPath);
-  const approval = verifyApproval(change, approvals, config, deltaContent ?? void 0);
-  const living = livingRequirementsMap2(workspace.specs);
-  const lintFindings = change.delta ? lintDelta(change.delta, living, deltaPath, { language: config.spec.language }) : [];
-  const trace = checkTrace({
-    specs: workspace.specs,
-    change,
-    requireEvidence: config.gates.verify.mode !== "off" && config.gates.verify.require_evidence
-  });
-  const blocking = lintFindings.filter((d) => d.severity === "error").length + trace.findings.filter((d) => d.severity === "error").length;
-  const mockupsAreReady = requiresMockups(change.meta, config) ? await mockupsReady(workspace.root, change.slug, change) : void 0;
-  const state = deriveState({
-    change,
-    cfg: config,
-    approval,
-    blockingFindings: change.delta ? blocking : 0,
-    ...mockupsAreReady !== void 0 ? { mockupsReady: mockupsAreReady } : {}
-  });
-  return { change, approval, lintFindings, trace, blocking, state };
-}
-
 // src/commands/next.ts
 async function runNext(ctx) {
   const { workspace, config, approvals } = await requireWorkspace(ctx);
@@ -14372,7 +14988,7 @@ async function runNext(ctx) {
 }
 
 // src/commands/present.ts
-import path35 from "path";
+import path37 from "path";
 async function runPresentCommand(ctx) {
   const { root } = await requireWorkspace(ctx);
   const slug = ctx.positionals[0];
@@ -14384,7 +15000,7 @@ async function runPresentCommand(ctx) {
   if (result.path) {
     lines.push("Propuesta generada");
     lines.push("");
-    lines.push(`  archivo: ${path35.relative(ctx.cwd, result.path)}`);
+    lines.push(`  archivo: ${path37.relative(ctx.cwd, result.path)}`);
     if (result.hash) lines.push(`  hash de la spec: ${shortHash(result.hash)}`);
     lines.push("");
     lines.push("\xC1brela en el navegador y comp\xE1rtela con el stakeholder.");
@@ -14394,7 +15010,7 @@ async function runPresentCommand(ctx) {
   return {
     exitCode: hasErrors2 ? 1 : 0,
     diagnostics: result.diagnostics,
-    data: result.path ? { path: path35.relative(ctx.cwd, result.path), hash: result.hash } : void 0,
+    data: result.path ? { path: path37.relative(ctx.cwd, result.path), hash: result.hash } : void 0,
     text: lines
   };
 }
@@ -14512,7 +15128,7 @@ async function runStatus(ctx) {
 }
 
 // src/commands/trace.ts
-import path36 from "path";
+import path38 from "path";
 async function runTrace(ctx) {
   const { workspace, config } = await requireWorkspace(ctx);
   const slug = flagString(ctx.flags, "change");
@@ -14532,7 +15148,7 @@ async function runTrace(ctx) {
     data.push({ slug: change.slug, nodes: result.graph.nodes.length, edges: result.graph.edges.length, summary: result.summary, findings: result.findings });
     lines.push(`  ${change.slug}: ${result.graph.nodes.length} nodos, ${result.graph.edges.length} aristas, ${errors} errores, ${result.summary.warnings} avisos`);
     for (const finding of result.findings) {
-      const location = finding.path ? ` (${path36.relative(ctx.cwd, finding.path)}${finding.line ? `:${finding.line}` : ""})` : "";
+      const location = finding.path ? ` (${path38.relative(ctx.cwd, finding.path)}${finding.line ? `:${finding.line}` : ""})` : "";
       lines.push(`    ${finding.severity.toUpperCase()} ${finding.code} \u2014 ${finding.message}${location}`);
     }
   }
@@ -14542,7 +15158,7 @@ async function runTrace(ctx) {
 }
 
 // src/commands/validate.ts
-import path37 from "path";
+import path39 from "path";
 async function runValidate(ctx) {
   const { workspace, config, approvals } = await requireWorkspace(ctx);
   const slug = flagString(ctx.flags, "change");
@@ -14568,7 +15184,7 @@ async function runValidate(ctx) {
     for (const finding of evaluation.lintFindings) {
       lines.push(`    ${finding.severity.toUpperCase()} ${finding.code}${finding.line ? `:${finding.line}` : ""} \u2014 ${finding.message}`);
     }
-    lines.push(`    archivo: ${path37.relative(ctx.cwd, path37.join(change.dir, "spec.md"))}`);
+    lines.push(`    archivo: ${path39.relative(ctx.cwd, path39.join(change.dir, "spec.md"))}`);
   }
   if (targets.length === 0) lines.push("Sin cambios activos.");
   const errors = diagnostics.filter((d) => d.severity === "error").length;
@@ -14583,7 +15199,7 @@ async function runValidate(ctx) {
 }
 
 // src/commands/verify.ts
-import path38 from "path";
+import path40 from "path";
 async function runVerify(ctx) {
   const { root, workspace } = await requireWorkspace(ctx);
   const slug = ctx.positionals[0];
@@ -14626,7 +15242,7 @@ async function runVerify(ctx) {
     return { exitCode: 2, diagnostics: [{ code: "ATLAS-VERIFY-001", severity: "error", message: "Falta --by <nombre> (o define meta.owner)" }] };
   }
   const profilesDir = await resolveProfilesDir();
-  const profile = await loadActiveProfile(path38.join(root, ".sdd"), [profilesDir ?? "", path38.join(root, ".sdd", "profiles", "custom")].filter(Boolean));
+  const profile = await loadActiveProfile(path40.join(root, ".sdd"), [profilesDir ?? "", path40.join(root, ".sdd", "profiles", "custom")].filter(Boolean));
   const record = await recordEvidence({
     root,
     slug,
@@ -14648,7 +15264,7 @@ async function runVerify(ctx) {
     if (record.evidence.command) lines.push(`  comando: ${record.evidence.command}`);
     lines.push(`  resultado: ${record.evidence.result}`);
     if (record.evidence.outputHash) lines.push(`  hash:    ${record.evidence.outputHash}`);
-    lines.push(`  archivo: ${path38.relative(ctx.cwd, record.path)}`);
+    lines.push(`  archivo: ${path40.relative(ctx.cwd, record.path)}`);
     if (record.stdout) {
       lines.push("");
       lines.push("  salida (\xFAltimas l\xEDneas):");
@@ -14663,7 +15279,7 @@ async function runVerify(ctx) {
   return {
     exitCode: record.exitCode === 0 ? 0 : 1,
     diagnostics: record.diagnostics,
-    data: { evidence: record.evidence, path: path38.relative(ctx.cwd, record.path), exitCode: record.exitCode },
+    data: { evidence: record.evidence, path: path40.relative(ctx.cwd, record.path), exitCode: record.exitCode },
     text: lines
   };
 }
@@ -14708,7 +15324,7 @@ El cambio ${slug} no tiene tareas todav\xEDa.`] };
 }
 
 // src/cli.ts
-var HANDLERS = {
+var HANDLERS2 = {
   init: runInit,
   adopt: runAdopt,
   new: runNew,
@@ -14729,6 +15345,7 @@ var HANDLERS = {
   mockup: runMockup,
   present: runPresentCommand,
   ci: runCi,
+  mcp: runMcp,
   metrics: runMetrics,
   run: runRun,
   archive: runArchive,
@@ -14736,7 +15353,7 @@ var HANDLERS = {
   help: (ctx) => runHelp(ctx)
 };
 var COMMANDS = Object.fromEntries(
-  CATALOG.map((spec) => [spec.name, { description: spec.description, flags: spec.flags, handler: HANDLERS[spec.name] }])
+  CATALOG.map((spec) => [spec.name, { description: spec.description, flags: spec.flags, handler: HANDLERS2[spec.name] }])
 );
 function toEnvelope(command, result) {
   const warnings = result.diagnostics.filter((d) => d.severity !== "error").map(stripSeverity);
@@ -14761,7 +15378,7 @@ async function requireWorkspace(ctx) {
     throw new CliError("ATLAS-WS-001", msg("cli.noWorkspace", ctx.language), 2);
   }
   const { workspace, config } = await loadWorkspace(root);
-  const approvals = await loadApprovals(path39.join(root, ".sdd"));
+  const approvals = await loadApprovals(path41.join(root, ".sdd"));
   return { root, workspace, config, approvals: approvals.byArtifact };
 }
 var CliError = class extends Error {
@@ -14828,7 +15445,7 @@ function printResult(command, result, json2, language) {
   }
   const lines = [...result.text ?? []];
   for (const d of result.diagnostics) {
-    const location = d.path ? ` ${path39.relative(process.cwd(), d.path)}${d.line ? `:${d.line}` : ""}` : "";
+    const location = d.path ? ` ${path41.relative(process.cwd(), d.path)}${d.line ? `:${d.line}` : ""}` : "";
     lines.push(`${d.severity === "error" ? "ERROR" : d.severity === "warning" ? "AVISO" : "NOTA"}  ${d.code}${location} \u2014 ${d.message}`);
     if (d.suggestion) lines.push(`       \u21B3 ${d.suggestion}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specatlas",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "SpecAtlas: kernel determinista de Spec-Driven Development (CLI)",
   "license": "MIT",
   "type": "module",
@@ -40,7 +40,7 @@
   },
   "devDependencies": {
     "@specatlas/adapters": "0.1.1",
-    "@specatlas/core": "0.1.21"
+    "@specatlas/core": "0.1.22"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",