@specatlas/core 0.1.0

package/dist/index.js

@@ -0,0 +1,4008 @@
+import {
+  approvalsSchema,
+  artifactHash,
+  canonicalizeMarkdown,
+  changeMetaSchema,
+  countBySeverity,
+  diag,
+  hasErrors,
+  parseApprovals,
+  parseChangeMeta,
+  sha256,
+  shortHash,
+  signApproval
+} from "./chunk-2BFXQ65Q.js";
+import {
+  copyFile,
+  ensureDir,
+  exists,
+  isDirectory,
+  listDir,
+  listDirs,
+  readText,
+  readTextIfExists,
+  toPosix,
+  walkFiles,
+  writeText
+} from "./chunk-5RKNY2ZC.js";
+
+// src/version.ts
+var CORE_VERSION = "0.0.1";
+
+// src/model.ts
+var REQ_ID_RE = /^REQ-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}$/;
+var SCENARIO_ID_RE = /^REQ-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}-S\d+$/;
+var RULE_ID_RE = /^BR-[A-Z0-9]+(?:-[A-Z0-9]+)*-\d{3}$/;
+var TASK_ID_RE = /^T[A-Za-z0-9]+\.\d+$/;
+
+// src/config.ts
+import path from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z } from "zod";
+var CONFIG_FILE = "config.yaml";
+var atlasConfigSchema = z.object({
+  schema_version: z.number().int().positive().default(1),
+  project: z.object({
+    name: z.string().default("proyecto"),
+    language: z.enum(["es", "en"]).default("es")
+  }).default({}),
+  lanes: z.object({
+    default: z.enum(["fix", "standard", "full"]).default("standard"),
+    allowed: z.array(z.enum(["fix", "standard", "full"])).default(["fix", "standard", "full"])
+  }).default({}),
+  gates: z.object({
+    approval: z.enum(["file", "none", "github-label"]).default("file"),
+    approval_label: z.string().default("spec-approved"),
+    analyze: z.object({ mode: z.enum(["off", "advisory", "blocking"]).default("blocking"), min_severity: z.enum(["low", "medium", "high"]).default("medium") }).default({}),
+    verify: z.object({ mode: z.enum(["off", "advisory", "blocking"]).default("blocking"), require_evidence: z.boolean().default(true) }).default({}),
+    review: z.object({ mode: z.enum(["off", "advisory", "blocking"]).default("advisory") }).default({}),
+    mockup: z.object({ require_approval: z.boolean().default(false), compare_in_verify: z.boolean().default(false) }).default({})
+  }).default({}),
+  trace: z.object({ mode: z.enum(["off", "advisory", "blocking"]).default("blocking"), prefix: z.string().default("REQ") }).default({}),
+  waves: z.object({ max_parallel: z.number().int().min(1).max(8).default(3) }).default({}),
+  ci: z.object({ drift: z.enum(["advisory", "strict"]).default("advisory") }).default({}),
+  spec: z.object({
+    language: z.enum(["es", "en"]).default("es"),
+    business_only: z.boolean().default(true),
+    glossary: z.string().default(".sdd/glossary.md")
+  }).default({}),
+  syntax: z.object({ headers: z.enum(["es", "en"]).optional() }).default({}),
+  mockups: z.object({
+    level: z.enum(["sketch", "hifi"]).default("hifi"),
+    platform: z.enum(["auto", "web", "mobile", "desktop"]).default("auto"),
+    a11y: z.enum(["off", "A", "AA", "AAA"]).default("AA")
+  }).default({}),
+  editor: z.object({ vscode: z.boolean().default(true), lsp: z.boolean().default(true) }).default({}),
+  adapters: z.object({
+    targets: z.array(z.enum(["opencode", "claude-code", "cursor", "copilot", "gemini", "codex", "generic"])).default(["opencode", "generic"])
+  }).default({}),
+  packs: z.array(z.string()).default([]),
+  integrations: z.object({ tracker: z.enum(["none", "github", "jira", "linear", "clickup"]).default("none") }).default({})
+});
+function defaultConfig(overrides = {}) {
+  return atlasConfigSchema.parse({
+    project: { name: overrides.name ?? "proyecto", language: overrides.language ?? "es" }
+  });
+}
+function configToYaml(cfg) {
+  const header = "# Configuraci\xF3n de SpecAtlas\n# language: es por defecto; en solo si el equipo trabaja en ingl\xE9s.\n# Los gates aceptan: off | advisory | blocking\n\n";
+  return header + stringifyYaml(cfg, { lineWidth: 120 });
+}
+function parseConfig(raw, configPath = CONFIG_FILE) {
+  let data;
+  try {
+    data = parseYaml(raw) ?? {};
+  } catch (err) {
+    return {
+      config: defaultConfig(),
+      diagnostics: [diag("ATLAS-CONFIG-001", "error", `YAML inv\xE1lido en ${configPath}: ${err.message}`, { path: configPath })]
+    };
+  }
+  const parsed = atlasConfigSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      config: defaultConfig(),
+      diagnostics: parsed.error.issues.map(
+        (issue) => diag("ATLAS-CONFIG-002", "error", `Configuraci\xF3n inv\xE1lida en ${issue.path.join(".") || "(ra\xEDz)"}: ${issue.message}`, {
+          path: configPath,
+          suggestion: "Corrige config.yaml seg\xFAn el esquema documentado"
+        })
+      )
+    };
+  }
+  const cfg = parsed.data;
+  const diagnostics = [];
+  if (cfg.spec.language !== cfg.project.language) {
+    diagnostics.push(
+      diag("ATLAS-CONFIG-003", "warning", `spec.language (${cfg.spec.language}) difiere de project.language (${cfg.project.language})`, {
+        path: configPath,
+        suggestion: "Iguala ambos valores para evitar mezclar idiomas"
+      })
+    );
+  }
+  if (!cfg.lanes.allowed.includes(cfg.lanes.default)) {
+    diagnostics.push(
+      diag("ATLAS-CONFIG-004", "error", `El carril por defecto "${cfg.lanes.default}" no est\xE1 en lanes.allowed`, { path: configPath })
+    );
+  }
+  return { config: cfg, diagnostics };
+}
+async function loadConfig(sddDir) {
+  const configPath = path.join(sddDir, CONFIG_FILE);
+  const raw = await readTextIfExists(configPath);
+  if (raw === void 0) {
+    return {
+      config: defaultConfig(),
+      diagnostics: [
+        diag("ATLAS-CONFIG-000", "warning", "No existe .sdd/config.yaml; se usan valores por defecto (language: es)", {
+          path: configPath,
+          suggestion: "Ejecuta `satlas init` para generar la configuraci\xF3n"
+        })
+      ]
+    };
+  }
+  return parseConfig(raw, configPath);
+}
+async function writeConfig(sddDir, cfg) {
+  await writeText(path.join(sddDir, CONFIG_FILE), configToYaml(cfg));
+}
+function laneOrDefault(cfg, lane) {
+  if (lane === "fix" || lane === "standard" || lane === "full") return lane;
+  return cfg.lanes.default;
+}
+
+// src/frontmatter.ts
+import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+var FM_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseFrontmatter(content, filePath) {
+  const diagnostics = [];
+  const match = FM_RE.exec(content);
+  if (!match) {
+    return { data: {}, body: content, bodyStartLine: 1, diagnostics };
+  }
+  const rawYaml = match[1] ?? "";
+  let data;
+  try {
+    data = parseYaml2(rawYaml) ?? {};
+  } catch (err) {
+    diagnostics.push(
+      diag("LINT-STR-000", "error", `Frontmatter YAML inv\xE1lido: ${err.message}`, {
+        path: filePath,
+        line: 1
+      })
+    );
+    return { data: {}, body: content.slice(match[0].length), bodyStartLine: 1, diagnostics };
+  }
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    diagnostics.push(diag("LINT-STR-000", "error", "El frontmatter debe ser un objeto YAML", { path: filePath, line: 1 }));
+    data = {};
+  }
+  const consumed = match[0].split("\n").length - 1;
+  return { data, body: content.slice(match[0].length), bodyStartLine: consumed + 1, diagnostics };
+}
+function emitFrontmatter(data, body) {
+  if (Object.keys(data).length === 0) return body;
+  const yaml = stringifyYaml2(data, { lineWidth: 120 }).trimEnd();
+  return `---
+${yaml}
+---
+
+${body}`;
+}
+function getString(data, key) {
+  const v = data[key];
+  return typeof v === "string" ? v : void 0;
+}
+function getNumber(data, key) {
+  const v = data[key];
+  return typeof v === "number" ? v : void 0;
+}
+
+// src/parse/spec.ts
+var REQ_HEAD_RE = /^###\s+(?:Requirement|Requisito):\s+(REQ-[A-Z0-9-]+)\s*(?:—|-|–)\s*(.+?)\s*$/;
+var SCENARIO_HEAD_RE = /^####\s+(?:Scenario|Escenario):\s+(REQ-[A-Z0-9-]+-S\d+)\s*(?:—|-|–)\s*(.+?)\s*$/;
+var RULE_RE = /^-\s*(?:Rule|Regla)\s+(BR-[A-Z0-9-]+)\s*:\s*(.+?)\s*$/;
+var WHEN_RE = /^-\s*\*\*\s*(?:WHEN|CUANDO|DADO QUE)\s*\*\*\s*(.+?)\s*$/i;
+var THEN_RE = /^-\s*\*\*\s*(?:THEN|ENTONCES|Y|AND)\s*\*\*\s*(.+?)\s*$/i;
+function newDraft(id, title, line) {
+  return { id, title, line, prose: [], rules: [], scenarios: [] };
+}
+function finalize(draft) {
+  return {
+    id: draft.id,
+    title: draft.title,
+    prose: draft.prose.join("\n").trim(),
+    rules: draft.rules,
+    scenarios: draft.scenarios,
+    line: draft.line
+  };
+}
+function parseRequirementBlocks(body, startLine = 1, filePath) {
+  const diagnostics = [];
+  const lines = body.replace(/\r\n?/g, "\n").split("\n");
+  const requirements = [];
+  let current;
+  let currentScenario;
+  const seenIds = /* @__PURE__ */ new Set();
+  const seenScenarios = /* @__PURE__ */ new Set();
+  const pushCurrent = () => {
+    if (current) requirements.push(finalize(current));
+    current = void 0;
+    currentScenario = void 0;
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const lineNo = startLine + i;
+    const reqMatch = REQ_HEAD_RE.exec(line);
+    if (reqMatch) {
+      pushCurrent();
+      const id = (reqMatch[1] ?? "").toUpperCase();
+      if (!REQ_ID_RE.test(id)) {
+        diagnostics.push(diag("LINT-STR-001", "error", `Id de requisito mal formado: ${id}`, { path: filePath, line: lineNo, suggestion: "Formato: REQ-DOMINIO-NNN" }));
+      }
+      if (seenIds.has(id)) {
+        diagnostics.push(diag("TRACE-008", "error", `Requisito duplicado: ${id}`, { path: filePath, line: lineNo }));
+      }
+      seenIds.add(id);
+      current = newDraft(id, reqMatch[2] ?? "", lineNo);
+      continue;
+    }
+    const scenMatch = SCENARIO_HEAD_RE.exec(line);
+    if (scenMatch) {
+      const id = (scenMatch[1] ?? "").toUpperCase();
+      if (!current) {
+        diagnostics.push(diag("LINT-STR-002", "error", `Escenario ${id} fuera de un requisito`, { path: filePath, line: lineNo }));
+        continue;
+      }
+      if (!SCENARIO_ID_RE.test(id)) {
+        diagnostics.push(diag("LINT-STR-001", "error", `Id de escenario mal formado: ${id}`, { path: filePath, line: lineNo }));
+      }
+      if (seenScenarios.has(id)) {
+        diagnostics.push(diag("TRACE-008", "error", `Escenario duplicado: ${id}`, { path: filePath, line: lineNo }));
+      }
+      seenScenarios.add(id);
+      currentScenario = { id, title: scenMatch[2] ?? "", reqId: current.id, when: [], then: [], line: lineNo };
+      current.scenarios.push(currentScenario);
+      continue;
+    }
+    const ruleMatch = RULE_RE.exec(line);
+    if (ruleMatch) {
+      const id = (ruleMatch[1] ?? "").toUpperCase();
+      if (!RULE_ID_RE.test(id)) {
+        diagnostics.push(diag("LINT-STR-001", "error", `Id de regla mal formado: ${id}`, { path: filePath, line: lineNo, suggestion: "Formato: BR-DOMINIO-NNN" }));
+      }
+      if (!current) {
+        diagnostics.push(diag("LINT-STR-002", "error", `Regla ${id} fuera de un requisito`, { path: filePath, line: lineNo }));
+        continue;
+      }
+      current.rules.push({ id, text: ruleMatch[2] ?? "", line: lineNo });
+      continue;
+    }
+    const whenMatch = WHEN_RE.exec(line);
+    if (whenMatch && currentScenario) {
+      currentScenario.when.push(whenMatch[1] ?? "");
+      continue;
+    }
+    const thenMatch = THEN_RE.exec(line);
+    if (thenMatch && currentScenario) {
+      currentScenario.then.push(thenMatch[1] ?? "");
+      continue;
+    }
+    if (current && !currentScenario) {
+      if (line.trim() !== "") current.prose.push(line.trim());
+    }
+  }
+  pushCurrent();
+  for (const req of requirements) {
+    for (const sc of req.scenarios) {
+      if (sc.then.length === 0) {
+        diagnostics.push(diag("LINT-BIZ-005", "error", `El escenario ${sc.id} no tiene THEN/ENTONCES`, { path: filePath, line: sc.line, suggestion: "A\xF1ade al menos un resultado observable" }));
+      }
+    }
+  }
+  return { requirements, diagnostics };
+}
+function parseSpecFile(content, filePath) {
+  const fm = parseFrontmatter(content, filePath);
+  const { requirements, diagnostics } = parseRequirementBlocks(fm.body, fm.bodyStartLine, filePath);
+  const spec = {
+    path: filePath,
+    frontmatter: fm.data,
+    requirements,
+    diagnostics: [...fm.diagnostics, ...diagnostics]
+  };
+  const domain = fm.data["domain"];
+  if (typeof domain === "string") spec.domain = domain;
+  const title = fm.data["title"];
+  if (typeof title === "string") spec.title = title;
+  const version = fm.data["version"];
+  if (typeof version === "number") spec.version = version;
+  return spec;
+}
+function renderRequirement(req, language = "es") {
+  const es = language !== "en";
+  const out = [];
+  out.push(`### ${es ? "Requisito" : "Requirement"}: ${req.id} \u2014 ${req.title}`);
+  if (req.prose) out.push(req.prose);
+  if (req.rules.length > 0) out.push("");
+  for (const rule of req.rules) out.push(`- ${es ? "Regla" : "Rule"} ${rule.id}: ${rule.text}`);
+  for (const sc of req.scenarios) {
+    out.push("");
+    out.push(`#### ${es ? "Escenario" : "Scenario"}: ${sc.id} \u2014 ${sc.title}`);
+    for (const w of sc.when) out.push(`- **${es ? "CUANDO" : "WHEN"}** ${w}`);
+    for (const t of sc.then) out.push(`- **${es ? "ENTONCES" : "THEN"}** ${t}`);
+  }
+  return out.join("\n");
+}
+
+// src/parse/delta.ts
+var NOUN = "(?:Requirements?|Requisitos?)";
+function sectionRe(ops) {
+  const words = ops.join("|");
+  return new RegExp(`^##\\s+(?:(?:${words})\\s+${NOUN}|${NOUN}\\s+(?:${words}))\\s*$`, "i");
+}
+var SECTION_DEFS = [
+  { op: "added", re: sectionRe(["ADDED", "AGREGADOS", "AGREGADAS", "A\xD1ADIDOS", "A\xD1ADIDAS"]) },
+  { op: "modified", re: sectionRe(["MODIFIED", "MODIFICADOS", "MODIFICADAS"]) },
+  { op: "removed", re: sectionRe(["REMOVED", "ELIMINADOS", "ELIMINADAS", "QUITADOS", "QUITADAS"]) },
+  { op: "renamed", re: sectionRe(["RENAMED", "RENOMBRADOS", "RENOMBRADAS"]) }
+];
+var FROM_RE = /^\s*-?\s*(?:FROM|DESDE):\s*(REQ-[A-Z0-9-]+)\s*(?:—|-|–)\s*(.+?)\s*$/i;
+var TO_RE = /^\s*-?\s*(?:TO|HACIA):\s*(REQ-[A-Z0-9-]+)\s*(?:—|-|–)\s*(.+?)\s*$/i;
+var REASON_RE = /^-\s*(?:Reason|Motivo|Razón):\s*(.+?)\s*$/im;
+var MIGRATION_RE = /^-\s*(?:Migration|Migración):\s*(.+?)\s*$/im;
+function parseDelta(content, filePath) {
+  const diagnostics = [];
+  const lines = content.replace(/\r\n?/g, "\n").split("\n");
+  const added = [];
+  const modified = [];
+  const removed = [];
+  const renamed = [];
+  const sectionsFound = [];
+  let currentOp;
+  let buffer = [];
+  let bufferStart = 1;
+  const flush = () => {
+    if (!currentOp || buffer.length === 0) {
+      buffer = [];
+      return;
+    }
+    const body = buffer.join("\n");
+    if (currentOp === "added" || currentOp === "modified") {
+      const parsed = parseRequirementBlocks(body, bufferStart, filePath);
+      diagnostics.push(...parsed.diagnostics);
+      if (currentOp === "added") added.push(...parsed.requirements);
+      else modified.push(...parsed.requirements);
+    } else if (currentOp === "removed") {
+      const parsed = parseRequirementBlocks(body, bufferStart, filePath);
+      diagnostics.push(...parsed.diagnostics);
+      for (const req of parsed.requirements) {
+        const blockText = body;
+        if (!REASON_RE.test(extractBlock(blockText, req.id))) {
+          diagnostics.push(diag("LINT-DLT-002", "error", `El requisito eliminado ${req.id} no declara "Motivo:"`, { path: filePath, line: req.line, suggestion: "A\xF1ade - Motivo: ... y - Migraci\xF3n: ..." }));
+        }
+        const hasMigration = MIGRATION_RE.test(extractBlock(blockText, req.id));
+        if (!hasMigration) {
+          diagnostics.push(diag("LINT-DLT-002", "error", `El requisito eliminado ${req.id} no declara "Migraci\xF3n:"`, { path: filePath, line: req.line, suggestion: "A\xF1ade - Migraci\xF3n: ... indicando c\xF3mo migrar" }));
+        }
+        removed.push(req);
+      }
+    } else if (currentOp === "renamed") {
+      let pendingFrom;
+      for (let i = 0; i < buffer.length; i += 1) {
+        const line = buffer[i] ?? "";
+        const from = FROM_RE.exec(line);
+        if (from) {
+          pendingFrom = { id: (from[1] ?? "").toUpperCase(), title: from[2] ?? "", line: bufferStart + i };
+          continue;
+        }
+        const to = TO_RE.exec(line);
+        if (to) {
+          if (!pendingFrom) {
+            diagnostics.push(diag("LINT-DLT-003", "error", 'RENAMED: "TO/HACIA" sin "FROM/DESDE" previo', { path: filePath, line: bufferStart + i }));
+            continue;
+          }
+          renamed.push({ from: { id: pendingFrom.id, title: pendingFrom.title }, to: { id: (to[1] ?? "").toUpperCase(), title: to[2] ?? "" }, line: pendingFrom.line });
+          pendingFrom = void 0;
+        }
+      }
+      if (pendingFrom) {
+        diagnostics.push(diag("LINT-DLT-003", "error", `RENAMED: ${pendingFrom.id} sin l\xEDnea "TO/HACIA"`, { path: filePath, line: pendingFrom.line }));
+      }
+    }
+    buffer = [];
+  };
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const section = SECTION_DEFS.find((s) => s.re.test(line));
+    if (section) {
+      flush();
+      currentOp = section.op;
+      sectionsFound.push(section.op);
+      bufferStart = i + 2;
+      continue;
+    }
+    if (currentOp) buffer.push(line);
+  }
+  flush();
+  const ops = new Set(sectionsFound);
+  for (const req of modified) {
+    if (req.scenarios.length === 0) {
+      diagnostics.push(diag("LINT-DLT-001", "error", `MODIFIED ${req.id} debe copiar el bloque completo (incluye escenarios)`, { path: filePath, line: req.line, suggestion: "Copia el bloque completo de la spec viva y ed\xEDtalo" }));
+    }
+  }
+  const delta = { path: filePath, added, modified, removed, renamed, sectionsFound: [...ops], diagnostics };
+  return delta;
+}
+function extractBlock(body, reqId) {
+  const lines = body.split("\n");
+  const start = lines.findIndex((l) => l.includes(reqId));
+  if (start < 0) return body;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^###\s+/.test(lines[i] ?? "")) {
+      end = i;
+      break;
+    }
+  }
+  return lines.slice(start, end).join("\n");
+}
+
+// src/parse/tasks.ts
+var BLOCK_HEAD_RE = /^##\s+(?:Block|Bloque)\s+([A-Za-z0-9._-]+)\s*(?:—|-|–)\s*(.+?)\s*$/;
+var TASK_LINE_RE = /^(\s*)-\s*\[([ xX])\]\s+(T[A-Za-z0-9]+\.\d+)\s+(.+?)\s*$/;
+var KEY_ALIASES = {
+  files: "files",
+  archivos: "files",
+  covers: "covers",
+  cubre: "covers",
+  depends: "depends",
+  "depende de": "depends",
+  rollback: "rollback",
+  reversi\u00F3n: "rollback",
+  "infra": "infra"
+};
+function normalizeKey(value) {
+  return value.trim().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+var KEY_ALIASES_NORMALIZED = Object.fromEntries(
+  Object.entries(KEY_ALIASES).map(([key, value]) => [normalizeKey(key), value])
+);
+var SEPARATOR = /\s+·\s+/;
+function parseTasksFile(content, filePath) {
+  const fm = parseFrontmatter(content, filePath);
+  const lines = fm.body.replace(/\r\n?/g, "\n").split("\n");
+  const diagnostics = [];
+  const blocks = [];
+  let current;
+  let done = 0;
+  let total = 0;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const lineNo = fm.bodyStartLine + i;
+    const blockMatch = BLOCK_HEAD_RE.exec(line);
+    if (blockMatch) {
+      current = { id: blockMatch[1] ?? "", title: blockMatch[2] ?? "", line: lineNo, tasks: [] };
+      blocks.push(current);
+      continue;
+    }
+    if (/^##\s+/.test(line)) {
+      current = void 0;
+      continue;
+    }
+    const taskMatch = TASK_LINE_RE.exec(line);
+    if (taskMatch) {
+      const isDone = (taskMatch[2] ?? "").toLowerCase() === "x";
+      const id = taskMatch[3] ?? "";
+      const rest = taskMatch[4] ?? "";
+      if (!TASK_ID_RE.test(id)) {
+        diagnostics.push(diag("LINT-STR-003", "error", `Id de tarea mal formado: ${id}`, { path: filePath, line: lineNo, suggestion: "Formato: T<bloque>.<secuencia>, por ejemplo T1.2" }));
+      }
+      if (!current) {
+        current = { id: id.split(".")[0]?.replace(/^T/, "") ?? "?", title: "(sin bloque)", line: lineNo, tasks: [] };
+        blocks.push(current);
+        diagnostics.push(diag("LINT-STR-004", "warning", `Tarea ${id} fuera de un bloque (## Block N \u2014 T\xEDtulo)`, { path: filePath, line: lineNo }));
+      }
+      const parts = rest.split(SEPARATOR);
+      const textParts = [];
+      const fields = {};
+      let metaStarted = false;
+      for (const part of parts) {
+        const kv = /^([A-Za-zÁÉÍÓÚÑáéíóúñ ]+)\s*:\s*(.*)$/.exec(part);
+        const key = kv ? KEY_ALIASES_NORMALIZED[normalizeKey(kv[1] ?? "")] : void 0;
+        const bareKey = KEY_ALIASES_NORMALIZED[normalizeKey(part)];
+        if (kv && key) {
+          metaStarted = true;
+          fields[key] = (kv[2] ?? "").trim();
+        } else if (bareKey) {
+          metaStarted = true;
+          fields[bareKey] = "";
+        } else if (!metaStarted) {
+          textParts.push(part);
+        }
+      }
+      const text = textParts.join(" \xB7 ").trim();
+      const task = {
+        id,
+        block: current.id,
+        text,
+        done: isDone,
+        files: splitList(fields["files"]),
+        covers: splitList(fields["covers"]).map((c) => c.toUpperCase()),
+        dependsOn: splitList(fields["depends"]).map((d) => d.toUpperCase()),
+        infra: fields["infra"] !== void 0,
+        line: lineNo
+      };
+      if (fields["rollback"] !== void 0) task.rollback = fields["rollback"];
+      if (task.files.length === 0 && !task.infra) {
+        diagnostics.push(diag("LINT-TSK-001", "warning", `La tarea ${id} no declara Archivos:`, { path: filePath, line: lineNo, suggestion: "A\xF1ade \xB7 Archivos: ruta/archivo.ext" }));
+      }
+      if (task.covers.length === 0 && !task.infra) {
+        diagnostics.push(diag("TRACE-004", "error", `La tarea ${id} no declara Cubre:`, { path: filePath, line: lineNo, suggestion: "A\xF1ade \xB7 Cubre: REQ-\u2026-S1 o marca \xB7 Infra si es trabajo de infraestructura" }));
+      }
+      current.tasks.push(task);
+      total += 1;
+      if (isDone) done += 1;
+      continue;
+    }
+  }
+  return { path: filePath, blocks, diagnostics, counts: { done, total } };
+}
+function splitList(value) {
+  if (!value) return [];
+  return value.split(",").map((v) => v.trim()).filter((v) => v.length > 0);
+}
+
+// src/parse/evidence.ts
+import { parse as parseYaml3 } from "yaml";
+import { z as z2 } from "zod";
+var evidenceSchema = z2.object({
+  scenario: z2.string().optional(),
+  method: z2.enum(["executable", "automatic", "semi", "manual"]),
+  command: z2.string().optional(),
+  result: z2.enum(["pass", "fail", "skipped"]),
+  output_hash: z2.string().optional(),
+  date: z2.string(),
+  by: z2.string(),
+  notes: z2.string().optional()
+});
+var FENCE_RE = /```evidence[ \t]*\r?\n([\s\S]*?)```/g;
+var HEAD_SCENARIO_RE = /^###\s+(REQ-[A-Z0-9-]+-S\d+)\b/;
+function parseVerifyFile(content, filePath) {
+  const diagnostics = [];
+  const evidence = [];
+  const normalized = content.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  for (const match of normalized.matchAll(FENCE_RE)) {
+    const startIndex = match.index ?? 0;
+    const line = normalized.slice(0, startIndex).split("\n").length;
+    const raw = match[1] ?? "";
+    let data;
+    try {
+      data = parseYaml3(raw);
+    } catch (err) {
+      diagnostics.push(diag("LINT-EVD-000", "error", `Bloque evidence con YAML inv\xE1lido: ${err.message}`, { path: filePath, line }));
+      continue;
+    }
+    const parsed = evidenceSchema.safeParse(data);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        diagnostics.push(diag("LINT-EVD-001", "error", `Evidencia inv\xE1lida (${issue.path.join(".") || "ra\xEDz"}): ${issue.message}`, { path: filePath, line }));
+      }
+      continue;
+    }
+    const value = parsed.data;
+    let scenario = value.scenario?.toUpperCase();
+    if (!scenario) {
+      scenario = findScenarioHeading(lines, line - 1);
+    }
+    if (!scenario) {
+      diagnostics.push(diag("LINT-EVD-002", "error", "La evidencia no indica escenario (clave scenario: o encabezado ### REQ-\u2026-S1)", { path: filePath, line }));
+      continue;
+    }
+    if (!SCENARIO_ID_RE.test(scenario)) {
+      diagnostics.push(diag("LINT-EVD-002", "error", `Escenario mal formado en evidencia: ${scenario}`, { path: filePath, line }));
+    }
+    if (value.method === "executable" && !value.command) {
+      diagnostics.push(diag("LINT-EVD-001", "error", `La evidencia ${scenario} es ejecutable pero no declara command`, { path: filePath, line }));
+    }
+    if (value.output_hash !== void 0 && !/^sha256:[0-9a-f]{8,64}$/i.test(value.output_hash)) {
+      diagnostics.push(diag("LINT-EVD-003", "warning", `output_hash con formato inesperado en ${scenario}`, { path: filePath, line, suggestion: "Formato: sha256:<hex>" }));
+    }
+    const ev = {
+      scenario,
+      method: value.method,
+      result: value.result,
+      date: value.date,
+      by: value.by,
+      line
+    };
+    if (value.command !== void 0) ev.command = value.command;
+    if (value.output_hash !== void 0) ev.outputHash = value.output_hash;
+    if (value.notes !== void 0) ev.notes = value.notes;
+    evidence.push(ev);
+  }
+  return { path: filePath, evidence, diagnostics };
+}
+function findScenarioHeading(lines, blockLineIndex) {
+  for (let i = blockLineIndex; i >= 0; i -= 1) {
+    const m = HEAD_SCENARIO_RE.exec(lines[i] ?? "");
+    if (m) return (m[1] ?? "").toUpperCase();
+    if (/^###\s+/.test(lines[i] ?? "") && !HEAD_SCENARIO_RE.test(lines[i] ?? "")) {
+      continue;
+    }
+  }
+  return void 0;
+}
+
+// src/lint.ts
+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"];
+var TECH_EN = ["database", "repository", "table", "column", "server", "deploy", "deployment", "branch", "merge", "commit", "cache", "queue", "endpoint", "microservice", "framework", "library", "package", "schema", "migration"];
+function wordBoundary(text, term) {
+  const escaped = term.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const re = new RegExp(`(?<![\\p{L}\\p{N}])${escaped}(?![\\p{L}\\p{N}])`, "iu");
+  return re.test(text);
+}
+function lintText(text, code, terms, label, path18, line) {
+  const out = [];
+  const lower = text.toLowerCase();
+  for (const term of terms) {
+    if (wordBoundary(lower, term)) {
+      out.push(
+        diag(code, "error", `${label}: "${term}"`, {
+          path: path18,
+          line,
+          suggestion: "La especificaci\xF3n es funcional y de negocio: describe comportamiento, no tecnolog\xEDa ni adjetivos vagos"
+        })
+      );
+    }
+  }
+  return out;
+}
+function lintRequirement(req, path18, opts = {}) {
+  const out = [];
+  const vague = opts.language === "en" ? VAGUE_EN : VAGUE_ES;
+  const tech = opts.language === "en" ? TECH_EN : TECH_ES;
+  const parts = [
+    { text: req.title, line: req.line },
+    { text: req.prose, line: req.line },
+    ...req.rules.map((r) => ({ text: r.text, line: r.line })),
+    ...req.scenarios.flatMap((s) => [...s.when.map((w) => ({ text: w, line: s.line })), ...s.then.map((t) => ({ text: t, line: s.line }))])
+  ];
+  for (const part of parts) {
+    out.push(...lintText(part.text, "LINT-BIZ-002", vague, "Palabra vaga en la especificaci\xF3n", path18, part.line));
+    if (opts.businessOnly !== false) {
+      out.push(...lintText(part.text, "LINT-BIZ-001", tech, "Jerga t\xE9cnica en la especificaci\xF3n de negocio", path18, part.line));
+    }
+  }
+  if (req.scenarios.length === 0) {
+    out.push(diag("TRACE-001", "error", `El requisito ${req.id} no tiene ning\xFAn escenario`, { path: path18, line: req.line, suggestion: "A\xF1ade al menos un escenario CUANDO/ENTONCES" }));
+  }
+  return out;
+}
+function lintDelta(delta, livingRequirements, path18, opts = {}) {
+  const out = [...delta.diagnostics];
+  for (const req of [...delta.added, ...delta.modified]) {
+    out.push(...lintRequirement(req, path18, opts));
+  }
+  for (const req of delta.modified) {
+    const living = livingRequirements.get(req.id);
+    if (!living) {
+      out.push(diag("TRACE-007", "error", `MODIFIED ${req.id} no existe en la spec viva; usa ADDED`, { path: path18, line: req.line }));
+      continue;
+    }
+    for (const existing of living.scenarios) {
+      if (!req.scenarios.some((s) => s.id === existing.id)) {
+        out.push(
+          diag("TRACE-007", "error", `MODIFIED ${req.id} pierde el escenario ${existing.id}: copia el bloque completo`, {
+            path: path18,
+            line: req.line,
+            suggestion: "Copia el bloque completo de la spec viva y ed\xEDtalo; para quitarlo, decl\xE1ralo en REMOVED"
+          })
+        );
+      }
+    }
+  }
+  for (const req of delta.removed) {
+    const living = livingRequirements.get(req.id);
+    if (!living) {
+      out.push(diag("TRACE-007", "error", `REMOVED ${req.id} no existe en la spec viva`, { path: path18, line: req.line }));
+    }
+  }
+  for (const rename of delta.renamed) {
+    if (rename.from.id !== rename.to.id) {
+      out.push(diag("LINT-DLT-003", "error", `RENAMED cambia el id (${rename.from.id} \u2192 ${rename.to.id}); los ids son inmutables`, { path: path18, line: rename.line }));
+    }
+    if (!livingRequirements.has(rename.from.id)) {
+      out.push(diag("TRACE-007", "error", `RENAMED ${rename.from.id} no existe en la spec viva`, { path: path18, line: rename.line }));
+    }
+  }
+  return out;
+}
+function lintTasks(_tasks) {
+  return [];
+}
+function lintVerify(_verify) {
+  return [];
+}
+function lintSpec(spec, opts = {}) {
+  const out = [...spec.diagnostics];
+  for (const req of spec.requirements) {
+    for (const d of lintRequirement(req, spec.path, opts)) {
+      if (d.code === "TRACE-001") continue;
+      out.push(d);
+    }
+  }
+  return out;
+}
+
+// src/trace.ts
+function buildTraceGraph(input) {
+  const nodes = [];
+  const edges = [];
+  const { change } = input;
+  const reqIds = /* @__PURE__ */ new Set();
+  const scenarioIds = /* @__PURE__ */ new Set();
+  for (const spec of input.specs) {
+    for (const req of spec.spec.requirements) {
+      reqIds.add(req.id);
+      nodes.push({ kind: "requirement", id: req.id });
+      for (const sc of req.scenarios) {
+        scenarioIds.add(sc.id);
+        nodes.push({ kind: "scenario", id: sc.id });
+      }
+    }
+  }
+  for (const deltaList of [change.delta?.added ?? [], change.delta?.modified ?? []]) {
+    for (const req of deltaList) {
+      if (!reqIds.has(req.id)) nodes.push({ kind: "requirement", id: req.id });
+      reqIds.add(req.id);
+      for (const sc of req.scenarios) {
+        if (!scenarioIds.has(sc.id)) nodes.push({ kind: "scenario", id: sc.id });
+        scenarioIds.add(sc.id);
+      }
+    }
+  }
+  for (const block of change.tasks?.blocks ?? []) {
+    for (const task of block.tasks) {
+      nodes.push({ kind: "task", id: task.id });
+      for (const cover of task.covers) edges.push({ from: task.id, to: cover, kind: "covers" });
+      for (const dep of task.dependsOn) edges.push({ from: task.id, to: dep, kind: "depends" });
+    }
+  }
+  for (const ev of change.verify?.evidence ?? []) {
+    nodes.push({ kind: "evidence", id: `${ev.scenario}@${ev.line}` });
+    edges.push({ from: `${ev.scenario}@${ev.line}`, to: ev.scenario, kind: "evidences" });
+  }
+  return { nodes, edges };
+}
+function checkTrace(input) {
+  const { change, specs, requireEvidence } = input;
+  const findings = [];
+  const livingReqs = /* @__PURE__ */ new Map();
+  const allScenarioIds = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    for (const req of spec.spec.requirements) {
+      livingReqs.set(req.id, { id: req.id, scenarios: req.scenarios.map((s) => s.id) });
+      for (const sc of req.scenarios) allScenarioIds.add(sc.id);
+    }
+  }
+  const deltaAdded = change.delta?.added ?? [];
+  const deltaModified = change.delta?.modified ?? [];
+  const deltaScenarios = /* @__PURE__ */ new Set();
+  for (const req of [...deltaAdded, ...deltaModified]) {
+    for (const sc of req.scenarios) {
+      deltaScenarios.add(sc.id);
+      allScenarioIds.add(sc.id);
+    }
+  }
+  const taskById = /* @__PURE__ */ new Map();
+  const covers = /* @__PURE__ */ new Set();
+  for (const block of change.tasks?.blocks ?? []) {
+    for (const task of block.tasks) {
+      taskById.set(task.id, { id: task.id, covers: task.covers, dependsOn: task.dependsOn, block: task.block });
+      for (const c of task.covers) covers.add(c);
+    }
+  }
+  const coversExpanded = new Set(covers);
+  const deltaReqScenarios = /* @__PURE__ */ new Map();
+  for (const req of [...deltaAdded, ...deltaModified]) deltaReqScenarios.set(req.id, req.scenarios.map((s) => s.id));
+  for (const c of covers) {
+    const req = livingReqs.get(c);
+    if (req) for (const sc of req.scenarios) coversExpanded.add(sc);
+    const deltaScenariosOfReq = deltaReqScenarios.get(c);
+    if (deltaScenariosOfReq) for (const sc of deltaScenariosOfReq) coversExpanded.add(sc);
+  }
+  for (const req of [...deltaAdded, ...deltaModified]) {
+    if (req.scenarios.length === 0) {
+      findings.push(diag("TRACE-001", "error", `El requisito ${req.id} no tiene escenarios`, { path: change.delta?.path, line: req.line }));
+    }
+  }
+  for (const sc of deltaScenarios) {
+    if (!coversExpanded.has(sc)) {
+      findings.push(
+        diag("TRACE-002", "error", `El escenario ${sc} no est\xE1 cubierto por ninguna tarea`, {
+          path: change.tasks?.path ?? change.delta?.path,
+          suggestion: `A\xF1ade una tarea con \xB7 Cubre: ${sc}`
+        })
+      );
+    }
+  }
+  for (const task of taskById.values()) {
+    for (const c of task.covers) {
+      if (!livingReqs.has(c) && !deltaScenarios.has(c) && !allScenarioIds.has(c)) {
+        findings.push(
+          diag("TRACE-003", "error", `La tarea ${task.id} cubre ${c}, que no existe`, {
+            path: change.tasks?.path,
+            suggestion: "Corrige el id o crea el requisito/escenario"
+          })
+        );
+      }
+    }
+    for (const dep of task.dependsOn) {
+      const target = taskById.get(dep);
+      if (!target) {
+        findings.push(diag("TRACE-009", "error", `La tarea ${task.id} depende de ${dep}, que no existe`, { path: change.tasks?.path }));
+      } else if (target.block !== task.block) {
+        findings.push(diag("TRACE-009", "warning", `La tarea ${task.id} depende de ${dep} de otro bloque (${target.block})`, { path: change.tasks?.path }));
+      }
+    }
+  }
+  const cycles = findCycles(taskById);
+  for (const cycle of cycles) {
+    findings.push(diag("TRACE-010", "error", `Ciclo de dependencias: ${cycle.join(" \u2192 ")}`, { path: change.tasks?.path }));
+  }
+  const tasksDone = change.tasks !== void 0 && change.tasks.counts.total > 0 && change.tasks.counts.done === change.tasks.counts.total;
+  if (requireEvidence && tasksDone) {
+    const passed = new Set((change.verify?.evidence ?? []).filter((e) => e.result === "pass").map((e) => e.scenario));
+    for (const sc of deltaScenarios) {
+      if (!passed.has(sc)) {
+        findings.push(
+          diag("TRACE-005", "error", `El escenario ${sc} no tiene evidencia de verificaci\xF3n (result: pass)`, {
+            path: change.verify?.path ?? `changes/${change.slug}/verify.md`,
+            suggestion: `Registra evidencia: satlas verify --record ${sc} --command "\u2026"`
+          })
+        );
+      }
+    }
+  }
+  const knownScenarios = /* @__PURE__ */ new Set([...allScenarioIds, ...deltaScenarios]);
+  for (const ev of change.verify?.evidence ?? []) {
+    if (!knownScenarios.has(ev.scenario)) {
+      findings.push(diag("TRACE-006", "warning", `Evidencia hu\xE9rfana: ${ev.scenario} no existe`, { path: change.verify?.path, line: ev.line }));
+    }
+  }
+  const summary = countBySeverity(findings);
+  return { graph: buildTraceGraph(input), findings, summary };
+}
+function findCycles(taskById) {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const cycles = [];
+  const visit = (id, stack) => {
+    if (inStack.has(id)) {
+      const idx = stack.indexOf(id);
+      cycles.push([...stack.slice(idx), id]);
+      return;
+    }
+    if (visited.has(id)) return;
+    visited.add(id);
+    inStack.add(id);
+    stack.push(id);
+    for (const dep of taskById.get(id)?.dependsOn ?? []) {
+      if (taskById.has(dep)) visit(dep, stack);
+    }
+    stack.pop();
+    inStack.delete(id);
+  };
+  for (const id of taskById.keys()) visit(id, []);
+  return cycles;
+}
+
+// src/waves.ts
+function compareTaskIds(a, b) {
+  const parse = (id) => {
+    const m = /^T([A-Za-z0-9]+)\.(\d+)$/.exec(id);
+    if (!m) return [id, 0, 0];
+    const blockPart = m[1] ?? "";
+    const blockNum = Number.parseInt(blockPart, 10);
+    const isNumeric = !Number.isNaN(blockNum);
+    return [isNumeric ? "" : blockPart, isNumeric ? blockNum : 0, Number.parseInt(m[2] ?? "0", 10)];
+  };
+  const pa = parse(a);
+  const pb = parse(b);
+  if (pa[0] !== pb[0]) return pa[0] < pb[0] ? -1 : 1;
+  if (pa[1] !== pb[1]) return pa[1] - pb[1];
+  return pa[2] - pb[2];
+}
+function normalizeFile(file) {
+  return toPosix(file.trim().toLowerCase());
+}
+function planWaves(tasks, opts = {}) {
+  const maxParallel = Math.max(1, Math.min(opts.maxParallel ?? 3, 8));
+  const blocks = [];
+  let totalWaves = 0;
+  for (const block of tasks.blocks) {
+    const plan = planBlock(block, maxParallel);
+    blocks.push(plan);
+    totalWaves += plan.waves.length;
+  }
+  return {
+    maxParallel,
+    blocks,
+    summary: { blocks: blocks.length, waves: totalWaves, tasks: tasks.counts.total }
+  };
+}
+function planBlock(block, maxParallel) {
+  const diagnostics = [];
+  const degraded = [];
+  const allIds = new Set(block.tasks.map((t) => t.id));
+  const pending = block.tasks.filter((t) => !t.done).sort((a, b) => compareTaskIds(a.id, b.id));
+  const remaining = new Set(pending.map((t) => t.id));
+  for (const task of pending) {
+    for (const dep of task.dependsOn) {
+      if (dep.startsWith("T") && !allIds.has(dep)) {
+        diagnostics.push(diag("TRACE-009", "error", `La tarea ${task.id} depende de ${dep}, que no existe en el bloque`, { line: task.line }));
+        degraded.push({ task: task.id, reason: "orphan-dependency", movedToWave: 0 });
+        remaining.delete(task.id);
+      }
+    }
+  }
+  const waves = [];
+  let guard = 0;
+  while (remaining.size > 0) {
+    guard += 1;
+    if (guard > pending.length + 2) {
+      for (const id of remaining) {
+        const task = pending.find((t) => t.id === id);
+        diagnostics.push(diag("TRACE-010", "error", `No se puede planificar ${id}: dependencia circular`, { line: task?.line }));
+      }
+      break;
+    }
+    const ready = pending.filter((t) => remaining.has(t.id) && t.dependsOn.every((dep) => !remaining.has(dep)));
+    if (ready.length === 0) {
+      for (const id of remaining) {
+        const task = pending.find((t) => t.id === id);
+        diagnostics.push(diag("TRACE-010", "error", `La tarea ${id} no puede planificarse: dependencia bloqueada`, { line: task?.line }));
+      }
+      break;
+    }
+    const wave = [];
+    const filesInWave = /* @__PURE__ */ new Set();
+    for (const task of ready) {
+      if (wave.length >= maxParallel) break;
+      const files = task.files.map(normalizeFile);
+      if (files.some((f) => filesInWave.has(f))) continue;
+      for (const f of files) filesInWave.add(f);
+      wave.push(task);
+    }
+    if (wave.length === 0) {
+      const first = ready[0];
+      if (first) wave.push(first);
+    }
+    for (const task of wave) remaining.delete(task.id);
+    waves.push(wave);
+    for (const task of pending) {
+      if (!remaining.has(task.id)) continue;
+      if (task.files.map(normalizeFile).some((f) => filesInWave.has(f))) {
+        degraded.push({ task: task.id, reason: "file-collision", movedToWave: waves.length + 1 });
+      }
+    }
+  }
+  return { block: block.id, title: block.title, waves, degraded, diagnostics };
+}
+
+// src/lifecycle.ts
+import path2 from "path";
+function verifyApproval(change, approvals, cfg, specContent) {
+  if (cfg.gates.approval === "none") return { status: "not_required" };
+  if ((change.meta?.overrides ?? []).some((o) => o.gate === "approval")) return { status: "overridden" };
+  if (!change.delta) return { status: "missing" };
+  const key = path2.posix.join("changes", change.slug, "spec.md");
+  const approval = approvals.get(key) ?? approvals.get(`${key}`);
+  if (!approval) return { status: "missing" };
+  if (specContent === void 0) return { status: "valid", approvedBy: approval.by, approvedAt: approval.at };
+  const current = artifactHash(specContent);
+  if (current !== approval.hash) return { status: "stale", approvedBy: approval.by, approvedAt: approval.at };
+  return { status: "valid", approvedBy: approval.by, approvedAt: approval.at };
+}
+function deriveState(input) {
+  const { change, cfg, approval, blockingFindings } = input;
+  const lane = change.meta?.lane ?? cfg.lanes.default;
+  const tasksTotal = change.tasks?.counts.total ?? 0;
+  const tasksDone = change.tasks?.counts.done ?? 0;
+  const deltaScenarios = [...change.delta?.added ?? [], ...change.delta?.modified ?? []].flatMap((r) => r.scenarios);
+  const passed = new Set((change.verify?.evidence ?? []).filter((e) => e.result === "pass").map((e) => e.scenario));
+  const scenariosEvidenced = deltaScenarios.filter((s) => passed.has(s.id)).length;
+  const progress = { tasksDone, tasksTotal, scenariosEvidenced, scenariosTotal: deltaScenarios.length };
+  const blockedBy = [];
+  const next = (command, description, requiresAgent = false) => ({ command, description, requiresAgent });
+  if (change.meta?.paused) {
+    return { state: "building", blockedBy: [`pausado: ${change.meta.paused.reason}`], nextAction: next(`satlas resume ${change.slug}`, "Reanudar el cambio pausado"), progress };
+  }
+  if (lane === "fix") {
+    const fixEvidence = change.fix?.evidence ?? [];
+    if (fixEvidence.length === 0) {
+      return { state: "draft", blockedBy, nextAction: next(`/satlas-fix ${change.slug}`, "Investigar la causa ra\xEDz, aplicar el fix y registrar la evidencia", true), progress };
+    }
+    if (!fixEvidence.some((e) => e.result === "pass")) {
+      blockedBy.push("la evidencia del fix no est\xE1 en pass");
+      return { state: "built", blockedBy, nextAction: next(`satlas verify ${change.slug} --file fix`, "Corregir y registrar la evidencia del fix"), progress };
+    }
+    return { state: "ready", blockedBy, nextAction: next(`satlas archive ${change.slug}`, "Archivar el fix (carril express, sin plegar deltas)"), progress };
+  }
+  if (!change.delta) {
+    return { state: "draft", blockedBy, nextAction: next(`/satlas.specify ${change.slug}`, "Especificar el cambio (spec funcional y de negocio)", true), progress };
+  }
+  if (blockingFindings > 0) {
+    blockedBy.push(`${blockingFindings} hallazgo(s) bloqueante(s)`);
+    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") {
+    blockedBy.push(approval.status === "stale" ? "la firma de la spec qued\xF3 obsoleta (el archivo cambi\xF3)" : "la spec no est\xE1 aprobada");
+    return {
+      state: "awaiting_approval",
+      blockedBy,
+      nextAction: next(`satlas present ${change.slug}`, "Presentar la propuesta y firmar la aprobaci\xF3n (satlas approve)"),
+      progress
+    };
+  }
+  if (!change.planPath && !change.tasks) {
+    return { state: "approved", blockedBy, nextAction: next(`/satlas.plan ${change.slug}`, "Crear el plan t\xE9cnico y las tareas", true), progress };
+  }
+  if (tasksTotal > 0 && tasksDone < tasksTotal) {
+    return { state: "building", blockedBy, nextAction: next(`/satlas.build ${change.slug}`, `Construir en olas (${tasksDone}/${tasksTotal} tareas)`, true), progress };
+  }
+  if (cfg.gates.verify.mode !== "off" && cfg.gates.verify.require_evidence && deltaScenarios.length > 0 && scenariosEvidenced < deltaScenarios.length) {
+    blockedBy.push(`evidencia ${scenariosEvidenced}/${deltaScenarios.length}`);
+    return { state: "built", blockedBy, nextAction: next(`satlas verify ${change.slug}`, "Registrar evidencia por escenario"), progress };
+  }
+  if (lane === "full" && cfg.gates.review.mode === "blocking" && !change.verify) {
+    blockedBy.push("review pendiente");
+    return { state: "verified", blockedBy, nextAction: next(`/satlas.review ${change.slug}`, "Revisi\xF3n de c\xF3digo", true), progress };
+  }
+  return { state: "ready", blockedBy, nextAction: next(`satlas archive ${change.slug}`, "Archivar el cambio y plegar los deltas"), progress };
+}
+function stateLabel(state) {
+  const labels = {
+    draft: "borrador",
+    spec_draft: "spec en borrador",
+    awaiting_approval: "esperando aprobaci\xF3n",
+    approved: "aprobado",
+    planned: "planificado",
+    building: "construyendo",
+    built: "construido",
+    verified: "verificado",
+    ready: "listo para archivar",
+    archived: "archivado"
+  };
+  return labels[state];
+}
+
+// src/profiles.ts
+import path3 from "path";
+import { parse as parseYaml4 } from "yaml";
+import { z as z3 } from "zod";
+var profileSchema = z3.object({
+  name: z3.string().min(1),
+  display_name: z3.string().default(""),
+  detection: z3.object({
+    files: z3.array(z3.string()).default([]),
+    manifests: z3.array(z3.object({ file: z3.string(), contains: z3.array(z3.string()).default([]) })).default([]),
+    priority: z3.number().default(0)
+  }).default({}),
+  domains: z3.array(z3.string()).default([]),
+  commands: z3.object({ build: z3.string().optional(), lint: z3.string().optional(), test: z3.string().optional(), format: z3.string().optional() }).default({}),
+  verify: z3.object({ executable: z3.array(z3.string()).default([]), automatic: z3.array(z3.string()).default([]), manual: z3.array(z3.string()).default([]) }).default({}),
+  rollback: z3.string().default(""),
+  antipatterns: z3.array(z3.string()).default([]),
+  assumptions: z3.array(z3.string()).default([])
+});
+function globToRegExp(pattern) {
+  let re = "";
+  for (let i = 0; i < pattern.length; i += 1) {
+    const ch = pattern[i] ?? "";
+    if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 1;
+      } else {
+        re += "[^/]*";
+      }
+    } else if (ch === "?") {
+      re += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(ch)) {
+      re += `\\${ch}`;
+    } else {
+      re += ch;
+    }
+  }
+  return new RegExp(`^${re}$`, "i");
+}
+function matchGlob(pattern, filePath) {
+  const posix = toPosix(filePath);
+  return globToRegExp(pattern).test(posix) || globToRegExp(`**/${pattern}`).test(posix);
+}
+async function loadProfileFile(filePath) {
+  const raw = await readTextIfExists(filePath);
+  if (raw === void 0) return void 0;
+  let data;
+  try {
+    data = parseYaml4(raw);
+  } catch {
+    return void 0;
+  }
+  const parsed = profileSchema.safeParse(data);
+  return parsed.success ? parsed.data : void 0;
+}
+async function loadProfilesFromDir(dir) {
+  const entries = await listDir(dir);
+  const out = [];
+  for (const entry of entries) {
+    if (!/\.ya?ml$/i.test(entry)) continue;
+    const profile = await loadProfileFile(path3.join(dir, entry));
+    if (profile) out.push(profile);
+  }
+  return out;
+}
+async function detectProfiles(root, profiles) {
+  const files = await walkFiles(root);
+  const matches = [];
+  for (const profile of profiles) {
+    let score = 0;
+    for (const pattern of profile.detection.files) {
+      if (files.some((f) => matchGlob(pattern, f.path))) score += 2;
+    }
+    for (const manifest of profile.detection.manifests) {
+      const found = files.find((f) => matchGlob(manifest.file, f.path) || toPosix(f.path) === toPosix(manifest.file) || f.name === manifest.file);
+      if (!found) continue;
+      const content = await readTextIfExists(found.path) ?? "";
+      const containsAll = manifest.contains.every((c) => content.toLowerCase().includes(c.toLowerCase()));
+      if (containsAll) score += 3;
+    }
+    if (score > 0) {
+      const priority = profile.detection.priority ?? 0;
+      matches.push({
+        name: profile.name,
+        displayName: profile.display_name || profile.name,
+        score: score + Math.min(priority, 0) / 100,
+        domains: profile.domains,
+        path: profile.name
+      });
+    }
+  }
+  matches.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  const result = { matches };
+  const best = matches[0];
+  if (best) result.best = best;
+  return result;
+}
+async function loadDetectedBest(sddDir) {
+  const raw = await readTextIfExists(path3.join(sddDir, "profiles", "detected.yaml"));
+  if (raw === void 0) return void 0;
+  try {
+    const data = parseYaml4(raw);
+    return typeof data?.best === "string" ? data.best : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadActiveProfile(sddDir, dirs) {
+  const best = await loadDetectedBest(sddDir);
+  const profiles = [];
+  for (const dir of dirs) profiles.push(...await loadProfilesFromDir(dir));
+  if (best) {
+    const found = profiles.find((p) => p.name === best);
+    if (found) return found;
+  }
+  return profiles.find((p) => p.name === "generic");
+}
+function detectionToYaml(result, generatedAt) {
+  const lines = ["# Generado por `satlas init`. Editarlo a mano es v\xE1lido: no se sobrescribe.", `schema_version: 1`, `generated_at: ${generatedAt}`];
+  if (result.best) {
+    lines.push(`best: ${result.best.name}`);
+  } else {
+    lines.push("best: generic");
+  }
+  lines.push("candidates:");
+  if (result.matches.length === 0) {
+    lines.push("  - name: generic");
+    lines.push("    score: 0");
+  } else {
+    for (const m of result.matches) {
+      lines.push(`  - name: ${m.name}`);
+      lines.push(`    score: ${m.score}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/workspace.ts
+import path4 from "path";
+var SDD_DIR = ".sdd";
+async function findWorkspaceRoot(start) {
+  let current = path4.resolve(start);
+  for (let i = 0; i < 40; i += 1) {
+    if (await isDirectory(path4.join(current, SDD_DIR))) return current;
+    const parent = path4.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+  return void 0;
+}
+async function loadApprovals(sddDir) {
+  const file = path4.join(sddDir, "approvals.yaml");
+  const raw = await readTextIfExists(file);
+  if (raw === void 0) return { byArtifact: /* @__PURE__ */ new Map(), diagnostics: [] };
+  const parsed = parseApprovals(raw, file);
+  const map = /* @__PURE__ */ new Map();
+  for (const a of parsed.approvals?.approvals ?? []) {
+    map.set(a.artifact.split(path4.sep).join("/"), { hash: a.artifactHash, by: a.approvedBy, at: a.approvedAt });
+  }
+  return { byArtifact: map, diagnostics: parsed.diagnostics };
+}
+async function loadSpecs(sddDir) {
+  const specsDir = path4.join(sddDir, "specs");
+  const domains = await listDirs(specsDir);
+  const out = [];
+  for (const domain of domains) {
+    const file = path4.join(specsDir, domain, "spec.md");
+    if (!await exists(file)) continue;
+    const content = await readText(file);
+    out.push({ domain, path: file, spec: parseSpecFile(content, file) });
+  }
+  return out;
+}
+async function loadChange(root, slug) {
+  const dir = path4.join(root, SDD_DIR, "changes", slug);
+  const diagnostics = [];
+  const change = { slug, dir, diagnostics };
+  const metaFile = path4.join(dir, "meta.yaml");
+  const metaRaw = await readTextIfExists(metaFile);
+  if (metaRaw === void 0) {
+    diagnostics.push(diag("ATLAS-FILES-001", "error", `El cambio "${slug}" no tiene meta.yaml`, { path: metaFile, suggestion: "Crea meta.yaml con slug, lane y dominio" }));
+  } else {
+    const parsed = parseChangeMeta(metaRaw, metaFile);
+    diagnostics.push(...parsed.diagnostics);
+    if (parsed.meta) change.meta = parsed.meta;
+  }
+  const deltaFile = path4.join(dir, "spec.md");
+  const deltaRaw = await readTextIfExists(deltaFile);
+  if (deltaRaw !== void 0) {
+    change.delta = parseDelta(deltaRaw, deltaFile);
+    diagnostics.push(...change.delta.diagnostics);
+  } else {
+    diagnostics.push(diag("ATLAS-FILES-002", "warning", `El cambio "${slug}" no tiene spec.md (delta)`, { path: deltaFile }));
+  }
+  const planFile = path4.join(dir, "plan.md");
+  if (await exists(planFile)) change.planPath = planFile;
+  const tasksFile = path4.join(dir, "tasks.md");
+  const tasksRaw = await readTextIfExists(tasksFile);
+  if (tasksRaw !== void 0) {
+    change.tasks = parseTasksFile(tasksRaw, tasksFile);
+    diagnostics.push(...change.tasks.diagnostics);
+  }
+  const verifyFile = path4.join(dir, "verify.md");
+  const verifyRaw = await readTextIfExists(verifyFile);
+  if (verifyRaw !== void 0) {
+    change.verify = parseVerifyFile(verifyRaw, verifyFile);
+    diagnostics.push(...change.verify.diagnostics);
+  }
+  const fixFile = path4.join(dir, "fix.md");
+  const fixRaw = await readTextIfExists(fixFile);
+  if (fixRaw !== void 0) {
+    change.fix = parseVerifyFile(fixRaw, fixFile);
+    diagnostics.push(...change.fix.diagnostics);
+  }
+  const mockupManifest = path4.join(dir, "mockups", "manifest.yaml");
+  if (await exists(mockupManifest)) change.mockupManifestPath = mockupManifest;
+  return change;
+}
+async function listChangeSlugs(root, opts = {}) {
+  const changesDir = path4.join(root, SDD_DIR, "changes");
+  const dirs = await listDirs(changesDir);
+  return dirs.filter((d) => opts.includeArchived ? true : d !== "archive");
+}
+async function loadWorkspace(root) {
+  const sddDir = path4.join(root, SDD_DIR);
+  const { config, diagnostics: configDiags } = await loadConfig(sddDir);
+  const diagnostics = [...configDiags];
+  const specs = await loadSpecs(sddDir);
+  for (const spec of specs) diagnostics.push(...spec.spec.diagnostics);
+  const slugs = await listChangeSlugs(root);
+  const changes = [];
+  for (const slug of slugs) {
+    const change = await loadChange(root, slug);
+    changes.push(change);
+    diagnostics.push(...change.diagnostics);
+  }
+  return { workspace: { root, sddDir, specs, changes, diagnostics }, config };
+}
+async function ensureSddDirs(sddDir) {
+  const created = [];
+  const dirs = ["specs", "changes", "runs", "metrics", path4.join("profiles", "custom")];
+  const { ensureDir: ensureDir2 } = await import("./fsx-VF2P7ALA.js");
+  for (const d of dirs) {
+    const full = path4.join(sddDir, d);
+    if (!await exists(full)) {
+      await ensureDir2(full);
+      created.push(full);
+    }
+  }
+  return created;
+}
+
+// src/templates.ts
+import { stringify as stringifyYaml3 } from "yaml";
+var ES = {
+  constitution: `# Constituci\xF3n del proyecto
+
+> Reglas inmutables. Todo cambio las hereda. Jerarqu\xEDa: constituci\xF3n > spec aprobada > plan > tareas > c\xF3digo.
+
+## Art\xEDculo 1 \u2014 Verdad y evidencia
+Ninguna afirmaci\xF3n de "terminado" se acepta sin evidencia registrada en verify.md.
+
+## Art\xEDculo 2 \u2014 Seguridad
+No se versionan secretos. No se ejecutan comandos destructivos sin rollback documentado.
+
+## Art\xEDculo 3 \u2014 Especificaci\xF3n de negocio
+Las specs se escriben en lenguaje de negocio, sin tecnolog\xEDa. El plan t\xE9cnico es otro artefacto.
+
+## Art\xEDculo 4 \u2014 Trazabilidad
+Todo requisito tiene escenarios; todo escenario tiene tarea y evidencia. Los ids REQ-* son inmutables.
+
+## Art\xEDculo 5 \u2014 Cambios de alcance
+Lo aprobado no se edita en silencio: se firma una revisi\xF3n (satlas amend, disponible en F2).
+
+## Art\xEDculo 6 \u2014 Revisi\xF3n humana
+Aprobar, revisar y archivar son actos humanos registrados con nombre y fecha.
+
+<!-- A\xF1ade aqu\xED los art\xEDculos propios de tu proyecto. Ampl\xEDa sin miedo: esta plantilla es tuya. -->
+`,
+  glossary: `# Glosario de negocio
+
+> T\xE9rminos con el significado que les da el negocio. La spec usa estos t\xE9rminos, no sin\xF3nimos t\xE9cnicos.
+
+| T\xE9rmino | Definici\xF3n | Sin\xF3nimos aceptados |
+|---|---|---|
+| Cliente | Persona u organizaci\xF3n que contrata el servicio | Usuario |
+| Solicitud | Pedido formal de un cliente que inicia un proceso | Ticket |
+`,
+  proposal: `# Propuesta \u2014 {{TITLE}}
+
+## Por qu\xE9
+(problema u oportunidad, en lenguaje de negocio)
+
+## Qu\xE9 cambia
+(alcance funcional de la propuesta)
+
+## Fuera de alcance
+(lo que expl\xEDcitamente no se har\xE1)
+
+## C\xF3mo se mide el \xE9xito
+(indicadores observables)
+`,
+  specDelta: ({ title, domainUpper, domain }) => `# Delta \u2014 ${title}
+
+## Requisitos agregados
+
+### Requisito: REQ-${domainUpper}-001 \u2014 ${title}
+Describe la necesidad de negocio y el comportamiento esperado (sin tecnolog\xEDa).
+
+- Regla BR-${domainUpper}-001: (regla de negocio verificable)
+
+#### Escenario: REQ-${domainUpper}-001-S1 \u2014 Caso principal
+- **CUANDO** (situaci\xF3n o acci\xF3n del actor)
+- **ENTONCES** (resultado observable y medible)
+
+#### Escenario: REQ-${domainUpper}-001-S2 \u2014 Error o caso l\xEDmite
+- **CUANDO** (situaci\xF3n inv\xE1lida)
+- **ENTONCES** (respuesta del sistema)
+
+## Requisitos modificados
+
+## Requisitos eliminados
+
+## Requisitos renombrados
+
+<!-- dominio del cambio: ${domain} -->
+`,
+  plan: `# Plan \u2014 {{TITLE}}
+
+## 1. Contexto AS-IS
+(existe / no existe / blast radius; anclas al c\xF3digo real)
+
+## 2. Enfoque t\xE9cnico
+(decisiones y alternativas descartadas con su porqu\xE9)
+
+## 3. Diagramas
+Incluye los diagramas mermaid que el cambio necesita:
+
+| Tipo | Cu\xE1ndo |
+|---|---|
+| erDiagram | si toca modelo de datos o BD |
+| sequenceDiagram | integraciones, APIs, jobs, eventos |
+| flowchart | reglas de negocio, procesos, validaciones |
+| stateDiagram-v2 | m\xE1quinas de estado |
+| classDiagram | dominio o l\xF3gica no trivial |
+| C4Context / flowchart de capas | arquitectura o m\xF3dulos nuevos |
+
+\`\`\`mermaid
+flowchart LR
+  A[Entrada] --> B[Proceso] --> C[Resultado]
+\`\`\`
+
+## 4. Dise\xF1o por capa / m\xF3dulos
+
+## 5. Matriz de trazabilidad (REQ \u2192 tareas)
+| Requisito | Escenario | Tareas |
+|---|---|---|
+
+## 6. Matriz de paridad AS-IS \u2192 TO-BE (solo refactors sustitutivos)
+| Elemento | Conservar | Descartar (motivo) | Nuevo |
+|---|---|---|---|
+
+## 7. Tareas
+Ver tasks.md.
+
+## 8. Riesgos y mitigaciones
+
+## 9. Rollback
+
+## 10. Dependencias y supuestos
+`,
+  tasks: `# Tareas \u2014 {{TITLE}}
+
+## Bloque 1 \u2014 Preparaci\xF3n
+
+<!-- Cada tarea es at\xF3mica y usa el separador \xB7 :
+- [ ] T1.1 Descripci\xF3n \xB7 Archivos: ruta/al/archivo \xB7 Cubre: REQ-DOMINIO-001-S1 \xB7 Rollback: c\xF3mo revertir
+- [ ] T1.2 Otra tarea \xB7 Archivos: ruta/otra \xB7 Depende de: T1.1
+Para trabajo de infraestructura sin requisito: \xB7 Infra
+-->
+`,
+  verify: `# Verificaci\xF3n \u2014 {{TITLE}}
+
+> Una entrada por escenario con evidencia real (comando y resultado). Ejemplo:
+
+<!--
+### REQ-DOMINIO-001-S1 \u2014 Caso principal
+\`\`\`evidence
+method: executable
+command: npm test -- modulo
+result: pass
+output_hash: sha256:\u2026
+date: 2026-01-01T00:00:00Z
+by: tu-nombre
+notes: 12/12 casos
+\`\`\`
+-->
+`,
+  fix: `# Fix \u2014 {{TITLE}}
+
+## S\xEDntoma
+(qu\xE9 se observa, d\xF3nde y desde cu\xE1ndo)
+
+## Causa ra\xEDz
+(por qu\xE9 ocurre, con evidencia del c\xF3digo real)
+
+## Cambio
+(qu\xE9 se toca y por qu\xE9 es el m\xEDnimo cambio correcto)
+
+## Rollback
+(c\xF3mo revertir)
+
+## Evidencia
+
+<!-- Registra la evidencia real con:
+satlas verify <slug> --file fix --scenario REQ-DOMINIO-001-S1 --command "<comando>" --by "<nombre>"
+o, si es manual:
+satlas verify <slug> --file fix --scenario REQ-DOMINIO-001-S1 --method manual --result pass --by "<nombre>" --notes "<c\xF3mo se comprob\xF3>"
+-->
+`
+};
+var EN = {
+  constitution: `# Project constitution
+
+> Immutable rules. Every change inherits them. Hierarchy: constitution > approved spec > plan > tasks > code.
+
+## Article 1 \u2014 Truth and evidence
+No "done" claim is accepted without evidence recorded in verify.md.
+
+## Article 2 \u2014 Security
+No secrets in the repo. No destructive command without a documented rollback.
+
+## Article 3 \u2014 Business specification
+Specs are written in business language, without technology. The technical plan is a separate artifact.
+
+## Article 4 \u2014 Traceability
+Every requirement has scenarios; every scenario has a task and evidence. REQ-* ids are immutable.
+
+## Article 5 \u2014 Scope changes
+Approved work is never edited silently: a signed revision is required.
+
+## Article 6 \u2014 Human review
+Approving, reviewing and archiving are human acts recorded with name and date.
+`,
+  glossary: `# Business glossary
+
+> Terms as the business means them. Specs use these terms, not technical synonyms.
+
+| Term | Definition | Accepted synonyms |
+|---|---|---|
+| Customer | Person or organization that contracts the service | User |
+`,
+  proposal: `# Proposal \u2014 {{TITLE}}
+
+## Why
+(problem or opportunity in business language)
+
+## What changes
+(functional scope)
+
+## Out of scope
+
+## How success is measured
+`,
+  specDelta: ({ title, domainUpper, domain }) => `# Delta \u2014 ${title}
+
+## ADDED Requirements
+
+### Requirement: REQ-${domainUpper}-001 \u2014 ${title}
+Describe the business need and expected behaviour (no technology).
+
+- Rule BR-${domainUpper}-001: (verifiable business rule)
+
+#### Scenario: REQ-${domainUpper}-001-S1 \u2014 Main case
+- **WHEN** (situation or actor action)
+- **THEN** (observable, measurable result)
+
+#### Scenario: REQ-${domainUpper}-001-S2 \u2014 Error or edge case
+- **WHEN** (invalid situation)
+- **THEN** (system response)
+
+## MODIFIED Requirements
+
+## REMOVED Requirements
+
+## RENAMED Requirements
+
+<!-- change domain: ${domain} -->
+`,
+  plan: `# Plan \u2014 {{TITLE}}
+
+## 1. AS-IS context
+## 2. Technical approach
+## 3. Diagrams
+\`\`\`mermaid
+flowchart LR
+  A[Input] --> B[Process] --> C[Outcome]
+\`\`\`
+## 4. Layer / module design
+## 5. Traceability matrix (REQ \u2192 tasks)
+## 6. AS-IS \u2192 TO-BE parity matrix (replacing refactors only)
+## 7. Tasks
+See tasks.md.
+## 8. Risks and mitigations
+## 9. Rollback
+## 10. Dependencies and assumptions
+`,
+  tasks: `# Tasks \u2014 {{TITLE}}
+
+## Block 1 \u2014 Preparation
+
+<!--
+- [ ] T1.1 Description \xB7 Files: path/to/file \xB7 Covers: REQ-DOMAIN-001-S1 \xB7 Rollback: how to revert
+-->
+`,
+  verify: `# Verification \u2014 {{TITLE}}
+
+<!--
+### REQ-DOMAIN-001-S1 \u2014 Main case
+\`\`\`evidence
+method: executable
+command: npm test -- module
+result: pass
+output_hash: sha256:\u2026
+date: 2026-01-01T00:00:00Z
+by: your-name
+\`\`\`
+-->
+`,
+  fix: `# Fix \u2014 {{TITLE}}
+
+## Symptom
+## Root cause
+## Change
+## Rollback
+## Evidence
+
+<!-- Register real evidence with:
+satlas verify <slug> --file fix --scenario REQ-DOMAIN-001-S1 --command "<command>" --by "<name>"
+-->
+`
+};
+function templatesFor(language) {
+  return language === "en" ? EN : ES;
+}
+function renderTemplate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+function changeMetaYaml(meta) {
+  const doc = {
+    schema_version: meta.schemaVersion,
+    slug: meta.slug,
+    lane: meta.lane
+  };
+  if (meta.title) doc["title"] = meta.title;
+  if (meta.domain) doc["domain"] = meta.domain;
+  if (meta.risk) doc["risk"] = meta.risk;
+  if (meta.created) doc["created"] = meta.created;
+  if (meta.owner) doc["owner"] = meta.owner;
+  return `# Estado del cambio. La fase se DERIVA de los artefactos; aqu\xED solo hechos.
+` + stringifyYaml3(doc, { lineWidth: 120 });
+}
+function indexMarkdown(input) {
+  const es = input.language !== "en";
+  const lines = [];
+  lines.push(`# \xCDndice \u2014 ${input.projectName}`);
+  lines.push("");
+  lines.push(es ? `> Generado por SpecAtlas. No editar a mano: \`satlas doctor\` lo regenera.` : `> Generated by SpecAtlas. Do not edit by hand: \`satlas doctor\` regenerates it.`);
+  lines.push("");
+  lines.push(es ? "## Specs vivas" : "## Living specs");
+  lines.push("");
+  if (input.specs.length === 0) lines.push(es ? "_Sin specs todav\xEDa._" : "_No specs yet._");
+  for (const spec of input.specs) lines.push(`- \`${spec.domain}\` \u2014 ${spec.requirements} ${es ? "requisitos" : "requirements"}`);
+  lines.push("");
+  lines.push(es ? "## Cambios activos" : "## Active changes");
+  lines.push("");
+  if (input.changes.length === 0) lines.push(es ? "_Sin cambios activos._" : "_No active changes._");
+  for (const change of input.changes) lines.push(`- \`${change.slug}\` \u2014 ${change.lane}`);
+  lines.push("");
+  lines.push(es ? `## Archivados
+
+${input.archived} cambio(s) en \`changes/archive/\`.` : `## Archived
+
+${input.archived} change(s) in \`changes/archive/\`.`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/github.ts
+import path5 from "path";
+import { parse as parseYaml5 } from "yaml";
+
+// src/exec.ts
+import { execFile } from "child_process";
+var SHELL_META = /[;&|<>`$()\r\n]|[%!^]|&&|\|\|/;
+function hasShellMetacharacters(command) {
+  return SHELL_META.test(command);
+}
+function splitCommand(command) {
+  const parts = [];
+  let current = "";
+  let quote;
+  for (const ch of command.trim()) {
+    if (quote) {
+      if (ch === quote) quote = void 0;
+      else current += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (current !== "") parts.push(current);
+      current = "";
+      continue;
+    }
+    current += ch;
+  }
+  if (current !== "") parts.push(current);
+  return parts;
+}
+function firstToken(command) {
+  return splitCommand(command)[0] ?? "";
+}
+function run(binary, args, opts) {
+  const timeoutMs = opts.timeoutMs ?? 12e4;
+  const maxBytes = opts.maxBytes ?? 2e5;
+  const started = Date.now();
+  return new Promise((resolve) => {
+    const child = execFile(binary, args, { cwd: opts.cwd, timeout: timeoutMs, windowsHide: true, maxBuffer: maxBytes }, (error, stdout, stderr) => {
+      const durationMs = Date.now() - started;
+      const err = error;
+      const exitCode = err && typeof err.code === "number" ? err.code : err ? 1 : 0;
+      resolve({
+        ok: !err,
+        exitCode,
+        stdout: stdout ?? "",
+        stderr: stderr ?? "",
+        durationMs,
+        command: [binary, ...args].join(" "),
+        resolvedBinary: binary
+      });
+    });
+    child.on("error", () => {
+    });
+    if (opts.input !== void 0 && child.stdin) {
+      child.stdin.write(opts.input);
+      child.stdin.end();
+    }
+  });
+}
+async function runProcess(command, opts = {}) {
+  if (hasShellMetacharacters(command)) {
+    return {
+      ok: false,
+      exitCode: 126,
+      stdout: "",
+      stderr: `Comando rechazado: contiene metacaracteres de shell (; | & < > \` $ ( ) % !). Ejecuta un \xFAnico comando sin redirecciones.`,
+      durationMs: 0,
+      command,
+      resolvedBinary: ""
+    };
+  }
+  const parts = splitCommand(command);
+  const bin = parts[0] ?? "";
+  const args = parts.slice(1);
+  if (bin === "") {
+    return { ok: false, exitCode: 127, stdout: "", stderr: "Comando vac\xEDo", durationMs: 0, command, resolvedBinary: "" };
+  }
+  const first = await run(bin, args, opts);
+  if (!first.ok && first.exitCode !== 0 && /ENOENT/.test(first.stderr) && process.platform === "win32" && !/\.(exe|cmd|bat|ps1)$/i.test(bin)) {
+    const withCmd = await run(`${bin}.cmd`, args, opts);
+    if (withCmd.resolvedBinary.endsWith(".cmd")) return { ...withCmd, command };
+    return { ...first, command };
+  }
+  return { ...first, command };
+}
+function isCommandAllowed(command, allowedPrefixes) {
+  const token = firstToken(command).toLowerCase();
+  const base = token.replace(/\.(cmd|exe|bat|ps1)$/i, "");
+  return allowedPrefixes.some((prefix) => {
+    const first = firstToken(prefix).toLowerCase().replace(/\.(cmd|exe|bat|ps1)$/i, "");
+    return first === base;
+  });
+}
+
+// src/github.ts
+function parseGitHubRemote(url) {
+  const trimmed = url.trim();
+  const ssh = /^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/.exec(trimmed);
+  if (ssh) return { owner: ssh[1] ?? "", name: ssh[2] ?? "" };
+  const https = /^https?:\/\/github\.com\/([^/]+)\/(.+?)(?:\.git)?$/.exec(trimmed);
+  if (https) return { owner: https[1] ?? "", name: https[2] ?? "" };
+  const shorthand = /^([\w.-]+)\/([\w.-]+)$/.exec(trimmed);
+  if (shorthand) return { owner: shorthand[1] ?? "", name: shorthand[2] ?? "" };
+  return void 0;
+}
+function changeMarker(slug) {
+  return `<!-- specatlas:change=${slug} -->`;
+}
+var defaultRunner = (command, opts) => runProcess(command, opts);
+async function ghAvailable(runner = defaultRunner) {
+  const result = await runner("gh --version");
+  return result.ok;
+}
+async function ghAuthStatus(runner = defaultRunner) {
+  const result = await runner("gh auth status");
+  return result.ok;
+}
+async function detectRepo(root, runner = defaultRunner) {
+  const remote = await runner("git remote get-url origin", { cwd: root });
+  if (remote.ok) {
+    const parsed = parseGitHubRemote(remote.stdout.trim());
+    if (parsed) return parsed;
+  }
+  const view = await runner("gh repo view --json nameWithOwner -q .nameWithOwner", { cwd: root });
+  if (view.ok) {
+    const parsed = parseGitHubRemote(view.stdout.trim());
+    if (parsed) return parsed;
+  }
+  return void 0;
+}
+function issueBody(input) {
+  const { change } = input;
+  const lines = [];
+  lines.push(`## ${change.meta?.title ?? change.slug}`);
+  lines.push("");
+  lines.push(`- Cambio: \`${change.slug}\` \xB7 dominio \`${change.meta?.domain ?? "\u2014"}\` \xB7 carril \`${change.meta?.lane ?? "standard"}\``);
+  lines.push(`- Estado: ${change.meta?.paused ? "pausado" : "en curso"}`);
+  lines.push(`- Escenarios: ${input.scenarios}`);
+  lines.push(`- Siguiente: \`${input.next}\` \u2014 ${input.nextDescription}`);
+  lines.push("");
+  lines.push("### Artefactos");
+  lines.push(`- Spec: \`${path5.posix.join(".sdd", "changes", change.slug, "spec.md")}\``);
+  if (change.planPath) lines.push(`- Plan: \`${path5.posix.join(".sdd", "changes", change.slug, "plan.md")}\``);
+  if (change.tasks) lines.push(`- Tareas: ${change.tasks.counts.done}/${change.tasks.counts.total}`);
+  if (change.verify) lines.push(`- Evidencia registrada: ${change.verify.evidence.length}`);
+  lines.push("");
+  lines.push("---");
+  lines.push(changeMarker(change.slug));
+  return lines.join("\n");
+}
+async function findLinkedIssue(root, slug, runner = defaultRunner) {
+  const result = await runner(`gh issue list --state all --limit 10 --search "specatlas:change=${slug} in:body" --json number,url,title,state`, { cwd: root });
+  if (!result.ok) return void 0;
+  try {
+    const list = JSON.parse(result.stdout);
+    const first = list[0];
+    if (!first || typeof first.number !== "number") return void 0;
+    return { number: first.number, url: first.url ?? "", title: first.title ?? "", state: first.state ?? "OPEN" };
+  } catch {
+    return void 0;
+  }
+}
+function parseIssueUrl(url) {
+  const match = /https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/.exec(url);
+  if (!match) return void 0;
+  return { number: Number.parseInt(match[1] ?? "0", 10), url: url.trim(), title: "", state: "OPEN" };
+}
+async function createIssue(root, opts, runner = defaultRunner) {
+  const labels = (opts.labels ?? []).map((label) => ` --label "${label}"`).join("");
+  const result = await runner(`gh issue create --title "${opts.title.replace(/"/g, '\\"')}" --body-file -${labels}`, { cwd: root, input: opts.body });
+  if (!result.ok) {
+    return {
+      diagnostics: [
+        diag("ATLAS-GH-002", "error", `No se pudo crear el issue: ${(result.stderr || result.stdout).trim().slice(0, 300)}`, {
+          suggestion: "Verifica `gh auth status` y los permisos del repositorio"
+        })
+      ]
+    };
+  }
+  const url = result.stdout.split("\n").map((line) => line.trim()).find((line) => /github\.com\/.+\/issues\/\d+/.test(line));
+  const issue = url ? parseIssueUrl(url) : void 0;
+  return issue ? { issue, diagnostics: [] } : { diagnostics: [diag("ATLAS-GH-003", "error", "GitHub no devolvi\xF3 la URL del issue creado", { path: void 0 })] };
+}
+async function editIssue(root, number, opts, runner = defaultRunner) {
+  const parts = [`gh issue edit ${number}`];
+  if (opts.title) parts.push(`--title "${opts.title.replace(/"/g, '\\"')}"`);
+  if (opts.body !== void 0) parts.push("--body-file -");
+  const result = await runner(parts.join(" "), { cwd: root, ...opts.body !== void 0 ? { input: opts.body } : {} });
+  if (!result.ok) {
+    return [diag("ATLAS-GH-004", "error", `No se pudo actualizar el issue #${number}: ${(result.stderr || result.stdout).trim().slice(0, 300)}`)];
+  }
+  return [];
+}
+async function issueLabels(root, number, runner = defaultRunner) {
+  const result = await runner(`gh issue view ${number} --json labels`, { cwd: root });
+  if (!result.ok) {
+    return { labels: [], diagnostics: [diag("ATLAS-GH-005", "error", `No se pudo leer el issue #${number}: ${(result.stderr || result.stdout).trim().slice(0, 300)}`)] };
+  }
+  try {
+    const data = JSON.parse(result.stdout);
+    return { labels: (data.labels ?? []).map((label) => label.name ?? "").filter((name) => name !== ""), diagnostics: [] };
+  } catch {
+    return { labels: [], diagnostics: [diag("ATLAS-GH-005", "error", `Respuesta inesperada de gh para el issue #${number}`)] };
+  }
+}
+async function commentIssue(root, number, body, runner = defaultRunner) {
+  const result = await runner(`gh issue comment ${number} --body-file -`, { cwd: root, input: body });
+  return result.ok ? [] : [diag("ATLAS-GH-006", "error", `No se pudo comentar el issue #${number}: ${(result.stderr || result.stdout).trim().slice(0, 300)}`)];
+}
+async function patchChangeMeta(root, slug, patch) {
+  const file = path5.join(path5.resolve(root), ".sdd", "changes", slug, "meta.yaml");
+  const raw = await readTextIfExists(file);
+  if (raw === void 0) {
+    return { path: file, diagnostics: [diag("ATLAS-GH-007", "error", `No existe ${path5.relative(root, file)}`)] };
+  }
+  let data;
+  try {
+    data = parseYaml5(raw) ?? {};
+  } catch (err) {
+    return { path: file, diagnostics: [diag("ATLAS-GH-007", "error", `meta.yaml inv\xE1lido: ${err.message}`)] };
+  }
+  const { stringify } = await import("yaml");
+  await writeText(file, stringify({ ...data, ...patch }, { lineWidth: 120 }));
+  return { path: file, diagnostics: [] };
+}
+async function approveFromGithub(opts) {
+  const runner = opts.runner ?? defaultRunner;
+  const label = opts.label ?? "spec-approved";
+  const change = await loadChange(opts.root, opts.slug);
+  const tracker = change.meta?.tracker;
+  if (!tracker || tracker.provider !== "github" || !tracker.id) {
+    return {
+      approved: false,
+      label,
+      diagnostics: [
+        diag("ATLAS-GH-009", "error", `El cambio "${opts.slug}" no tiene un issue de GitHub vinculado`, {
+          suggestion: `Ejecuta \`satlas issue sync ${opts.slug}\` primero`
+        })
+      ]
+    };
+  }
+  const number = Number.parseInt(tracker.id, 10);
+  const { labels, diagnostics } = await issueLabels(opts.root, number, runner);
+  if (diagnostics.length > 0) return { approved: false, label, issueNumber: number, diagnostics };
+  if (!labels.includes(label)) {
+    return {
+      approved: false,
+      label,
+      issueNumber: number,
+      diagnostics: [
+        diag("ATLAS-GH-010", "warning", `El issue #${number} no tiene la etiqueta "${label}"`, {
+          suggestion: `Pide a quien aprueba que aplique la etiqueta "${label}" en el issue y vuelve a intentarlo`
+        })
+      ]
+    };
+  }
+  let by = opts.by?.trim();
+  if (!by) {
+    const me = await runner("gh api user -q .login", { cwd: opts.root });
+    by = me.ok ? me.stdout.trim() : "";
+  }
+  if (!by) {
+    return { approved: false, label, issueNumber: number, diagnostics: [diag("ATLAS-GH-011", "error", "No se pudo determinar qui\xE9n aprueba (--by ni `gh api user`)")] };
+  }
+  const { signApproval: signApproval2 } = await import("./approvals-HCBC7QDM.js");
+  const signed = await signApproval2({
+    root: opts.root,
+    artifact: path5.posix.join("changes", opts.slug, "spec.md"),
+    by,
+    channel: "tracker",
+    note: `Aprobado v\xEDa GitHub issue #${number} (etiqueta "${label}")`
+  });
+  return {
+    approved: signed.approval !== void 0,
+    label,
+    issueNumber: number,
+    approvedBy: by,
+    diagnostics: signed.diagnostics
+  };
+}
+async function syncGithubIssue(root, slug, opts = {}) {
+  const runner = opts.runner ?? defaultRunner;
+  const diagnostics = [];
+  if (!await ghAvailable(runner)) {
+    return {
+      slug,
+      created: false,
+      diagnostics: [
+        diag("ATLAS-GH-001", "error", "GitHub CLI (`gh`) no est\xE1 disponible", {
+          suggestion: "Instala gh (https://cli.github.com) y ejecuta `gh auth login`"
+        })
+      ]
+    };
+  }
+  if (!await ghAuthStatus(runner)) {
+    return { slug, created: false, diagnostics: [diag("ATLAS-GH-001", "error", "gh no est\xE1 autenticado", { suggestion: "Ejecuta `gh auth login`" })] };
+  }
+  const repo = await detectRepo(root, runner);
+  if (!repo) {
+    return {
+      slug,
+      created: false,
+      diagnostics: [diag("ATLAS-GH-008", "error", "No se detect\xF3 un repositorio de GitHub (remoto origin o `gh repo view`)")]
+    };
+  }
+  const change = await loadChange(root, slug);
+  const deltaScenarios = [...change.delta?.added ?? [], ...change.delta?.modified ?? []].flatMap((r) => r.scenarios);
+  const next = opts.next ?? { command: `satlas next ${slug}`, description: "Consulta la siguiente acci\xF3n" };
+  const body = issueBody({ change, next: next.command, nextDescription: next.description, scenarios: deltaScenarios.length });
+  const title = `${change.meta?.title ?? slug} (${slug})`;
+  const linked = change.meta?.tracker?.provider === "github" && change.meta.tracker.id ? { number: Number.parseInt(change.meta.tracker.id, 10), url: change.meta.tracker.url ?? "", title, state: "OPEN" } : await findLinkedIssue(root, slug, runner);
+  if (linked && Number.isFinite(linked.number)) {
+    diagnostics.push(...await editIssue(root, linked.number, { title, body }, runner));
+    if (change.meta?.tracker?.url !== linked.url && linked.url) {
+      diagnostics.push(...(await patchChangeMeta(root, slug, { tracker: { provider: "github", id: String(linked.number), url: linked.url } })).diagnostics);
+    }
+    return { slug, created: false, issue: linked, diagnostics };
+  }
+  const created = await createIssue(root, { title, body, ...opts.labels ? { labels: opts.labels } : {} }, runner);
+  diagnostics.push(...created.diagnostics);
+  if (created.issue) {
+    diagnostics.push(...(await patchChangeMeta(root, slug, { tracker: { provider: "github", id: String(created.issue.number), url: created.issue.url } })).diagnostics);
+  }
+  return { slug, created: true, ...created.issue ? { issue: created.issue } : {}, diagnostics };
+}
+
+// src/evidence.ts
+import path6 from "path";
+var SCENARIO_HEAD_RE2 = /^###\s+(REQ-[A-Z0-9-]+-S\d+)\b/;
+function locateBlocks(content) {
+  const normalized = content.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  const blocks = [];
+  let heading;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const head = SCENARIO_HEAD_RE2.exec(line);
+    if (head) heading = (head[1] ?? "").toUpperCase();
+    if (/^```evidence[ \t]*$/.test(line)) {
+      const start = i;
+      let j = i + 1;
+      while (j < lines.length && !/^```\s*$/.test(lines[j] ?? "")) j += 1;
+      const yamlLines = lines.slice(i + 1, j);
+      const yamlText = yamlLines.join("\n");
+      const scenarioInYaml = /scenario:\s*([A-Z0-9-]+)/i.exec(yamlText)?.[1]?.toUpperCase();
+      blocks.push({ scenario: scenarioInYaml ?? heading, start, end: j, yamlStart: i + 1, yamlEnd: j });
+      i = j;
+    }
+    i += 1;
+  }
+  void normalized;
+  return blocks;
+}
+function buildEvidenceYaml(evidence) {
+  const lines = [`method: ${evidence.method}`];
+  if (evidence.command) lines.push(`command: ${evidence.command}`);
+  lines.push(`result: ${evidence.result}`);
+  if (evidence.outputHash) lines.push(`output_hash: ${evidence.outputHash}`);
+  lines.push(`date: ${evidence.date}`);
+  lines.push(`by: ${evidence.by}`);
+  if (evidence.notes) lines.push(`notes: ${evidence.notes}`);
+  return lines.join("\n");
+}
+async function recordEvidence(opts) {
+  const root = path6.resolve(opts.root);
+  const slug = opts.slug;
+  const fileKind = opts.file ?? "verify";
+  const file = path6.join(root, ".sdd", "changes", slug, fileKind === "fix" ? "fix.md" : "verify.md");
+  const diagnostics = [];
+  const scenario = opts.scenario.toUpperCase();
+  if (!SCENARIO_ID_RE.test(scenario)) {
+    return { exitCode: 2, path: file, diagnostics: [diag("LINT-EVD-002", "error", `Escenario mal formado: ${opts.scenario}`, { suggestion: "Formato: REQ-DOMINIO-NNN-S1" })] };
+  }
+  if (!opts.by.trim()) {
+    return { exitCode: 2, path: file, diagnostics: [diag("ATLAS-VERIFY-001", "error", "Falta --by <nombre>: la evidencia es nominal")] };
+  }
+  let method = opts.method ?? (opts.command ? "executable" : "manual");
+  let result = opts.result ?? "pass";
+  let command = opts.command;
+  let outputHash;
+  let stdout;
+  let stderr;
+  let exitCode = 0;
+  if (method === "executable" || method === "automatic") {
+    if (!command) {
+      return { exitCode: 2, path: file, diagnostics: [diag("LINT-EVD-001", "error", `El m\xE9todo ${method} exige --command`)] };
+    }
+    if (hasShellMetacharacters(command)) {
+      return { exitCode: 2, path: file, diagnostics: [diag("ATLAS-EXEC-001", "error", "El comando contiene metacaracteres de shell y no se ejecutar\xE1", { suggestion: "Ejecuta un \xFAnico comando sin tuber\xEDas ni redirecciones" })] };
+    }
+    const allowed = opts.allowedPrefixes ?? [];
+    if (allowed.length > 0 && !opts.allowCommand && !isCommandAllowed(command, allowed)) {
+      return {
+        exitCode: 2,
+        path: file,
+        diagnostics: [
+          diag("ATLAS-EXEC-002", "error", `El comando no est\xE1 declarado en el perfil: "${command}"`, {
+            suggestion: `Comandos permitidos: ${allowed.join(" | ")}. Usa --allow-command si es intencional.`
+          })
+        ]
+      };
+    }
+    const exec = await runProcess(command, { cwd: root, timeoutMs: opts.timeoutMs });
+    exitCode = exec.exitCode;
+    stdout = exec.stdout;
+    stderr = exec.stderr;
+    result = opts.result ?? (exec.ok ? "pass" : "fail");
+    outputHash = sha256(`${exec.stdout}
+${exec.stderr}`);
+  } else if (opts.result === void 0) {
+    return { exitCode: 2, path: file, diagnostics: [diag("ATLAS-VERIFY-002", "error", `El m\xE9todo ${method} exige --result pass|fail|skipped`)] };
+  }
+  const evidence = {
+    scenario,
+    method,
+    result,
+    date: (opts.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    by: opts.by.trim(),
+    line: 0
+  };
+  if (command) evidence.command = command;
+  if (outputHash) evidence.outputHash = outputHash;
+  if (opts.notes) evidence.notes = opts.notes;
+  if (!opts.dryRun) {
+    const existing = await readTextIfExists(file) ?? `# Verificaci\xF3n \u2014 ${slug}
+`;
+    const blocks = locateBlocks(existing);
+    const yaml = buildEvidenceYaml(evidence);
+    const target = blocks.find((b) => b.scenario === scenario);
+    let next;
+    if (target) {
+      const normalized = existing.replace(/\r\n?/g, "\n");
+      const lines = normalized.split("\n");
+      next = [...lines.slice(0, target.yamlStart), ...yaml.split("\n"), ...lines.slice(target.yamlEnd)].join("\n");
+    } else {
+      const base = existing.replace(/\r\n?/g, "\n").trimEnd();
+      next = `${base}
+
+### ${scenario}
+
+\`\`\`evidence
+${yaml}
+\`\`\`
+`;
+    }
+    await writeText(file, next.replace(/\n{3,}/g, "\n\n"));
+  }
+  const returned = { evidence, exitCode: result === "pass" ? 0 : 1, path: file, diagnostics };
+  if (stdout !== void 0) returned.stdout = stdout;
+  if (stderr !== void 0) returned.stderr = stderr;
+  return returned;
+}
+function evidenceSummary(content) {
+  const out = /* @__PURE__ */ new Map();
+  for (const block of locateBlocks(content)) {
+    if (!block.scenario) continue;
+    const yamlText = content.replace(/\r\n?/g, "\n").split("\n").slice(block.yamlStart, block.yamlEnd).join("\n");
+    const result = /result:\s*(\w+)/i.exec(yamlText)?.[1];
+    if (result) out.set(block.scenario, result);
+  }
+  return out;
+}
+
+// src/runs.ts
+import path7 from "path";
+import { randomBytes } from "crypto";
+var RUN_EVENT_TYPES = [
+  "run_started",
+  "task_started",
+  "task_completed",
+  "wave_started",
+  "wave_completed",
+  "block_started",
+  "block_completed",
+  "validate_run",
+  "trace_run",
+  "analyze_run",
+  "verify_run",
+  "mockup_checked",
+  "presentation_generated",
+  "override_applied",
+  "paused",
+  "resumed",
+  "run_completed"
+];
+function generateRunId(now = /* @__PURE__ */ new Date()) {
+  const iso = now.toISOString().replace(/[-:T]/g, "").slice(0, 14);
+  return `${iso.slice(0, 8)}-${iso.slice(8, 14)}-${randomBytes(3).toString("hex")}`;
+}
+function runsDir(root) {
+  return path7.join(path7.resolve(root), ".sdd", "runs");
+}
+async function createRun(root, slug, phase, inputs, now = /* @__PURE__ */ new Date()) {
+  const runId = generateRunId(now);
+  const state = {
+    runId,
+    slug,
+    phase,
+    status: "active",
+    startedAt: now.toISOString(),
+    updatedAt: now.toISOString()
+  };
+  if (inputs) state.inputs = inputs;
+  const dir = path7.join(runsDir(root), runId);
+  await ensureDir(dir);
+  await writeText(path7.join(dir, "state.json"), `${JSON.stringify(state, null, 2)}
+`);
+  await writeText(path7.join(dir, "events.jsonl"), "");
+  await appendRunEvent(root, runId, "run_started", { slug, phase });
+  return state;
+}
+async function appendRunEvent(root, runId, type, data, now = /* @__PURE__ */ new Date()) {
+  const event = { eventId: randomBytes(4).toString("hex"), at: now.toISOString(), type };
+  if (data) event.data = data;
+  const file = path7.join(runsDir(root), runId, "events.jsonl");
+  const previous = await readTextIfExists(file) ?? "";
+  await writeText(file, `${previous}${JSON.stringify(event)}
+`);
+  return event;
+}
+async function updateRunStatus(root, runId, status, now = /* @__PURE__ */ new Date()) {
+  const file = path7.join(runsDir(root), runId, "state.json");
+  const raw = await readTextIfExists(file);
+  if (raw === void 0) return;
+  const state = JSON.parse(raw);
+  state.status = status;
+  state.updatedAt = now.toISOString();
+  await writeText(file, `${JSON.stringify(state, null, 2)}
+`);
+}
+async function readRun(root, runId) {
+  const dir = path7.join(runsDir(root), runId);
+  const stateRaw = await readTextIfExists(path7.join(dir, "state.json"));
+  if (stateRaw === void 0) {
+    return { diagnostics: [diag("ATLAS-RUN-001", "error", `No existe el run ${runId}`, { path: dir })] };
+  }
+  const state = JSON.parse(stateRaw);
+  const eventsRaw = await readTextIfExists(path7.join(dir, "events.jsonl")) ?? "";
+  const events = [];
+  for (const line of eventsRaw.split("\n")) {
+    if (line.trim() === "") continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return { record: { state, events }, diagnostics: [] };
+}
+async function listRuns(root, filter = {}) {
+  const dir = runsDir(root);
+  if (!await exists(dir)) return [];
+  const ids = await listDirs(dir);
+  const out = [];
+  for (const id of ids) {
+    const raw = await readTextIfExists(path7.join(dir, id, "state.json"));
+    if (raw === void 0) continue;
+    try {
+      const state = JSON.parse(raw);
+      if (filter.slug && state.slug !== filter.slug) continue;
+      if (filter.status && state.status !== filter.status) continue;
+      out.push(state);
+    } catch {
+    }
+  }
+  return out.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+
+// src/analyze.ts
+import path10 from "path";
+
+// src/mockups.ts
+import path8 from "path";
+import { parse as parseYaml6, stringify as stringifyYaml4 } from "yaml";
+import { z as z4 } from "zod";
+var mockupManifestSchema = z4.object({
+  schema_version: z4.number().int().positive().default(1),
+  version: z4.number().int().positive().default(1),
+  level: z4.enum(["sketch", "hifi"]).default("hifi"),
+  platform: z4.enum(["web", "mobile", "desktop"]).default("web"),
+  inputs_hash: z4.string().optional(),
+  generated_at: z4.string().optional(),
+  tokens: z4.string().optional(),
+  screens: z4.array(
+    z4.object({
+      id: z4.string(),
+      file: z4.string(),
+      title: z4.string().optional(),
+      illustrates: z4.array(z4.string()).default([]),
+      states: z4.array(z4.string()).default([]),
+      breakpoints: z4.array(z4.number()).default([]),
+      themes: z4.array(z4.string()).default([])
+    })
+  ).default([]),
+  screenshots: z4.array(z4.string()).default([])
+});
+var TOKEN_CANDIDATES = ["design/tokens.json", "DESIGN.md", "design/DESIGN.md", ".sdd/design/tokens.json"];
+function mockupsDir(root, slug) {
+  return path8.join(path8.resolve(root), ".sdd", "changes", slug, "mockups");
+}
+async function tokensFile(root) {
+  for (const candidate of TOKEN_CANDIDATES) {
+    const abs = path8.join(root, candidate);
+    if (await exists(abs)) return candidate;
+  }
+  return void 0;
+}
+async function computeInputsHash(root, change) {
+  const deltaPath = path8.join(change.dir, "spec.md");
+  const delta = await readTextIfExists(deltaPath) ?? "";
+  const tokens = await tokensFile(root);
+  const tokensContent = tokens ? await readTextIfExists(path8.join(root, tokens)) ?? "" : "";
+  return artifactHash(`${delta}
+---tokens---
+${tokensContent}`);
+}
+function planMockups(change, platform = "web") {
+  const screens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const requirement of [...change.delta?.added ?? [], ...change.delta?.modified ?? []]) {
+    if (seen.has(requirement.id)) continue;
+    seen.add(requirement.id);
+    const id = requirement.id.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    const states = platform === "mobile" ? ["default", "loading", "empty", "error", "offline"] : ["default", "loading", "empty", "error"];
+    screens.push({
+      id,
+      title: requirement.title,
+      file: `${id}.html`,
+      illustrates: requirement.scenarios.map((s) => s.id),
+      states,
+      breakpoints: platform === "mobile" ? [390, 768] : [390, 768, 1440]
+    });
+  }
+  return { platform, screens };
+}
+async function readMockupManifest(root, slug) {
+  const file = path8.join(mockupsDir(root, slug), "manifest.yaml");
+  const raw = await readTextIfExists(file);
+  if (raw === void 0) return { diagnostics: [] };
+  let data;
+  try {
+    data = parseYaml6(raw);
+  } catch (err) {
+    return { path: file, diagnostics: [diag("ATLAS-MKP-002", "error", `manifest.yaml inv\xE1lido: ${err.message}`, { path: file })] };
+  }
+  const parsed = mockupManifestSchema.safeParse(data);
+  if (!parsed.success) {
+    return {
+      path: file,
+      diagnostics: parsed.error.issues.map((issue) => diag("ATLAS-MKP-003", "error", `manifest.yaml (${issue.path.join(".") || "ra\xEDz"}): ${issue.message}`, { path: file }))
+    };
+  }
+  const v = parsed.data;
+  const manifest = {
+    schemaVersion: v.schema_version,
+    version: v.version,
+    level: v.level,
+    platform: v.platform,
+    screens: v.screens.map((s) => {
+      const screen = { id: s.id, file: s.file };
+      if (s.title !== void 0) screen.title = s.title;
+      if (s.illustrates.length > 0) screen.illustrates = s.illustrates;
+      if (s.states.length > 0) screen.states = s.states;
+      if (s.breakpoints.length > 0) screen.breakpoints = s.breakpoints;
+      if (s.themes.length > 0) screen.themes = s.themes;
+      return screen;
+    })
+  };
+  if (v.inputs_hash !== void 0) manifest.inputsHash = v.inputs_hash;
+  if (v.generated_at !== void 0) manifest.generatedAt = v.generated_at;
+  if (v.tokens !== void 0) manifest.tokens = v.tokens;
+  return { manifest, path: file, diagnostics: [] };
+}
+function lintMockupHtml(html, file) {
+  const findings = [];
+  if (!/mockup/i.test(html)) {
+    findings.push(diag("LINT-MKP-008", "error", 'El mockup no muestra el banner "MOCKUP \xB7 NO FUNCIONAL"', { path: file, suggestion: "A\xF1ade el banner visible con versi\xF3n y fecha" }));
+  }
+  if (/lorem ipsum/i.test(html)) {
+    findings.push(diag("LINT-MKP-003", "error", "El mockup usa Lorem ipsum", { path: file, suggestion: "Usa datos reales del glosario y del dominio" }));
+  }
+  if (/\bitem\s*\d+\b/i.test(html)) {
+    findings.push(diag("LINT-MKP-003", "warning", 'El mockup usa textos gen\xE9ricos ("Item 1")', { path: file, suggestion: "Usa datos realistas del dominio" }));
+  }
+  const external = /(src|href)\s*=\s*["']https?:/i.test(html) || /<script[^>]+src=/i.test(html) || /@import\s+url\(/i.test(html);
+  if (external) {
+    findings.push(diag("LINT-MKP-009", "error", "El mockup referencia recursos externos (red)", { path: file, suggestion: "Embebe fuentes, im\xE1genes y estilos en el propio HTML" }));
+  }
+  if (!/<meta[^>]+name=["']viewport["']/i.test(html)) {
+    findings.push(diag("LINT-MKP-010", "warning", "Falta la meta viewport", { path: file, suggestion: 'A\xF1ade <meta name="viewport" content="width=device-width, initial-scale=1">' }));
+  }
+  const states = new Set([...html.matchAll(/data-state=["']([^"']+)["']/gi)].map((m) => (m[1] ?? "").toLowerCase()));
+  if (states.size > 0 && states.size < 3) {
+    findings.push(diag("LINT-MKP-001", "warning", `El mockup solo declara ${states.size} estado(s)`, { path: file, suggestion: "Incluye default, loading, vac\xEDo y error" }));
+  }
+  return findings;
+}
+function lintMockupManifest(manifest, knownScenarios, file) {
+  const findings = [];
+  if (manifest.screens.length === 0) {
+    findings.push(diag("LINT-MKP-004", "error", "El manifiesto de mockups no declara pantallas", { path: file }));
+  }
+  for (const screen of manifest.screens) {
+    if (!screen.illustrates || screen.illustrates.length === 0) {
+      findings.push(diag("LINT-MKP-006", "error", `La pantalla "${screen.id}" no declara qu\xE9 escenarios ilustra`, { path: file, suggestion: "A\xF1ade illustrates: [REQ-\u2026-S1]" }));
+    }
+    for (const scenario of screen.illustrates ?? []) {
+      if (!SCENARIO_ID_RE.test(scenario) || !knownScenarios.has(scenario)) {
+        findings.push(diag("TRACE-011", "error", `La pantalla "${screen.id}" ilustra ${scenario}, que no existe en el cambio`, { path: file }));
+      }
+    }
+    if (!screen.states || screen.states.length === 0) {
+      findings.push(diag("LINT-MKP-001", "warning", `La pantalla "${screen.id}" no declara estados`, { path: file }));
+    }
+    if (!screen.breakpoints || screen.breakpoints.length === 0) {
+      findings.push(diag("LINT-MKP-002", "warning", `La pantalla "${screen.id}" no declara breakpoints`, { path: file }));
+    }
+  }
+  return findings;
+}
+async function checkMockups(root, slug, change) {
+  const dir = mockupsDir(root, slug);
+  if (!await exists(dir)) {
+    return { findings: [diag("LINT-MKP-004", "warning", "El cambio no tiene carpeta de mockups", { path: dir, suggestion: "Genera los mockups con la fase /satlas-mockup" })], stale: false };
+  }
+  const { manifest, path: manifestPath, diagnostics } = await readMockupManifest(root, slug);
+  const findings = [...diagnostics];
+  if (!manifest || !manifestPath) {
+    return { findings: [...findings, diag("LINT-MKP-004", "error", "No existe mockups/manifest.yaml", { path: path8.join(dir, "manifest.yaml") })], stale: false };
+  }
+  const known = /* @__PURE__ */ new Set();
+  for (const req of [...change.delta?.added ?? [], ...change.delta?.modified ?? []]) {
+    for (const scenario of req.scenarios) known.add(scenario.id);
+  }
+  findings.push(...lintMockupManifest(manifest, known, manifestPath));
+  for (const screen of manifest.screens) {
+    const html = await readTextIfExists(path8.join(dir, screen.file));
+    if (html === void 0) {
+      findings.push(diag("ATLAS-MKP-004", "error", `Falta el archivo del mockup: ${screen.file}`, { path: path8.join(dir, screen.file) }));
+      continue;
+    }
+    findings.push(...lintMockupHtml(html, path8.join(dir, screen.file)));
+  }
+  const inputsHash = await computeInputsHash(root, change);
+  const stale = manifest.inputsHash !== void 0 && manifest.inputsHash !== inputsHash;
+  if (stale) {
+    findings.push(
+      diag("MKP-STALE", "warning", "Los mockups est\xE1n desactualizados respecto a la spec (inputs_hash cambi\xF3)", {
+        path: manifestPath,
+        suggestion: "Regenera los mockups y vuelve a aprobarlos"
+      })
+    );
+  }
+  return { findings, stale, manifest, manifestPath };
+}
+async function writeMockupPlan(root, slug, plan, now = /* @__PURE__ */ new Date()) {
+  const file = path8.join(mockupsDir(root, slug), "plan.yaml");
+  if (await exists(file)) return file;
+  const doc = {
+    schema_version: 1,
+    generated_at: now.toISOString(),
+    platform: plan.platform,
+    screens: plan.screens.map((s) => ({ id: s.id, title: s.title, file: s.file, illustrates: s.illustrates, states: s.states, breakpoints: s.breakpoints }))
+  };
+  await writeText(file, stringifyYaml4(doc, { lineWidth: 120 }));
+  return file;
+}
+async function writeMockupManifest(root, slug, plan, inputsHash, now = /* @__PURE__ */ new Date()) {
+  const file = path8.join(mockupsDir(root, slug), "manifest.yaml");
+  if (await exists(file)) return file;
+  const doc = {
+    schema_version: 1,
+    version: 1,
+    level: "hifi",
+    platform: plan.platform,
+    inputs_hash: inputsHash,
+    generated_at: now.toISOString(),
+    screens: plan.screens.map((s) => ({ id: s.id, title: s.title, file: s.file, illustrates: s.illustrates, states: s.states, breakpoints: s.breakpoints })),
+    screenshots: []
+  };
+  await writeText(file, stringifyYaml4(doc, { lineWidth: 120 }));
+  return file;
+}
+async function updateMockupScreenshots(root, slug, screenshots) {
+  const file = path8.join(mockupsDir(root, slug), "manifest.yaml");
+  const raw = await readTextIfExists(file);
+  if (raw === void 0) return void 0;
+  const data = parseYaml6(raw) ?? {};
+  data["screenshots"] = screenshots;
+  await writeText(file, stringifyYaml4(data, { lineWidth: 120 }));
+  return file;
+}
+async function captureMockups(root, slug, manifest, now = /* @__PURE__ */ new Date()) {
+  const diagnostics = [];
+  const dir = mockupsDir(root, slug);
+  let playwright;
+  try {
+    const dynamicImport = new Function("specifier", "return import(specifier)");
+    playwright = await dynamicImport("playwright");
+  } catch {
+    diagnostics.push(
+      diag("ATLAS-MKP-001", "warning", "Playwright no est\xE1 instalado: captura omitida", {
+        suggestion: "Instala playwright (npm i -D playwright) y reintenta, o valida los mockups manualmente"
+      })
+    );
+    return { screenshots: [], diagnostics };
+  }
+  const browser = await playwright.chromium.launch({ channel: process.platform === "win32" ? "msedge" : void 0 });
+  const screenshots = [];
+  try {
+    for (const screen of manifest.screens) {
+      const page2 = await browser.newPage();
+      for (const bp of screen.breakpoints && screen.breakpoints.length > 0 ? screen.breakpoints : [1440]) {
+        await page2.setViewportSize({ width: bp, height: 900 });
+        await page2.goto(`file://${path8.join(dir, screen.file).split(path8.sep).join("/")}`);
+        const rel = path8.posix.join("screens", `${screen.id}-${bp}.png`);
+        await page2.screenshot({ path: path8.join(dir, rel) });
+        screenshots.push(rel);
+      }
+      await page2.close();
+    }
+  } finally {
+    await browser.close();
+  }
+  void now;
+  return { screenshots, diagnostics };
+}
+
+// src/packs.ts
+import path9 from "path";
+import { parse as parseYaml7 } from "yaml";
+import { z as z5 } from "zod";
+var checkSchema = z5.object({
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  type: z5.enum(["task-rollback", "evidence-strong", "spec-terms", "rule-terms", "nfr-measurable", "approval-provider"]),
+  severity: z5.enum(["error", "warning", "info"]).default("warning"),
+  applies_to: z5.object({ domains: z5.array(z5.string()).optional(), lanes: z5.array(z5.enum(["fix", "standard", "full"])).optional() }).optional(),
+  params: z5.object({ terms: z5.array(z5.string()).optional() }).optional(),
+  hint: z5.string().optional()
+});
+var packSchema = z5.object({
+  id: z5.string().min(1),
+  title: z5.string().min(1),
+  description: z5.string().default(""),
+  checks: z5.array(checkSchema).min(1)
+});
+var BUILTIN_PACKS = [
+  {
+    id: "seguridad",
+    title: "Seguridad de la informaci\xF3n",
+    description: "Controles m\xEDnimos para cambios que tocan autenticaci\xF3n, datos o infraestructura.",
+    source: "builtin",
+    checks: [
+      {
+        id: "SEG-1",
+        title: "Toda tarea declara c\xF3mo revertir",
+        type: "task-rollback",
+        severity: "error",
+        hint: "A\xF1ade \xB7 Reversi\xF3n: <c\xF3mo revertir> a cada tarea del cambio."
+      },
+      {
+        id: "SEG-2",
+        title: "La evidencia es automatizable (no manual)",
+        type: "evidence-strong",
+        severity: "warning",
+        appliesTo: { domains: ["backend", "database", "infra", "fullstack"] },
+        hint: "Registra la evidencia con un comando real (satlas verify --command) o una comprobaci\xF3n autom\xE1tica."
+      },
+      {
+        id: "SEG-3",
+        title: "Los requisitos nombran el control de seguridad",
+        type: "rule-terms",
+        severity: "warning",
+        params: { terms: ["autenticaci\xF3n", "autorizaci\xF3n", "permiso", "cifrado", "secreto", "token", "sesi\xF3n"] },
+        hint: "Si el cambio toca seguridad, descr\xEDbelo en una regla (BR-*): qui\xE9n accede, con qu\xE9 permiso y c\xF3mo se protege."
+      }
+    ]
+  },
+  {
+    id: "datos",
+    title: "Datos personales y privacidad",
+    description: "Controles de privacidad para cambios que tratan datos de personas.",
+    source: "builtin",
+    checks: [
+      {
+        id: "DAT-1",
+        title: "Se declara la finalidad y el ciclo de vida del dato",
+        type: "rule-terms",
+        severity: "warning",
+        params: { terms: ["datos personales", "consentimiento", "retenci\xF3n", "anonimiz", "privacidad", "eliminaci\xF3n"] },
+        hint: "A\xF1ade una regla de negocio que diga para qu\xE9 se usan los datos y cu\xE1ndo se eliminan."
+      },
+      {
+        id: "DAT-2",
+        title: "Toda tarea declara c\xF3mo revertir",
+        type: "task-rollback",
+        severity: "error",
+        hint: "A\xF1ade \xB7 Reversi\xF3n: <c\xF3mo revertir> a cada tarea del cambio."
+      },
+      {
+        id: "DAT-3",
+        title: "Los escenarios cubren la eliminaci\xF3n o exportaci\xF3n",
+        type: "spec-terms",
+        severity: "warning",
+        params: { terms: ["elimin", "export", "borrar", "anonimiz"] },
+        hint: "Incluye un escenario donde la persona ejerce sus derechos sobre el dato."
+      }
+    ]
+  },
+  {
+    id: "auditoria",
+    title: "Auditor\xEDa y control interno",
+    description: "Controles para procesos financieros o regulados: rastro completo y evidencia fuerte.",
+    source: "builtin",
+    checks: [
+      {
+        id: "AUD-1",
+        title: "Toda tarea declara c\xF3mo revertir",
+        type: "task-rollback",
+        severity: "error"
+      },
+      {
+        id: "AUD-2",
+        title: "Evidencia ejecutable o autom\xE1tica (sin manual)",
+        type: "evidence-strong",
+        severity: "error",
+        hint: "Un proceso auditado no se cierra con evidencia manual: usa pruebas, .http o un script."
+      },
+      {
+        id: "AUD-3",
+        title: "Se declara el rastro de auditor\xEDa",
+        type: "rule-terms",
+        severity: "warning",
+        params: { terms: ["auditor\xEDa", "registra", "hist\xF3rico", "trazabilidad", "comprobante"] },
+        hint: "Describe qu\xE9 queda registrado, con qu\xE9 datos y qui\xE9n puede consultarlo."
+      },
+      {
+        id: "AUD-4",
+        title: "La aprobaci\xF3n no est\xE1 desactivada",
+        type: "approval-provider",
+        severity: "error",
+        hint: "Configura gates.approval en `file` o `github-label`: un proceso auditado exige firma nominal."
+      }
+    ]
+  },
+  {
+    id: "accesibilidad",
+    title: "Accesibilidad (WCAG AA)",
+    description: "Controles para interfaces web y m\xF3viles.",
+    source: "builtin",
+    checks: [
+      {
+        id: "ACC-1",
+        title: "Los escenarios de interfaz cubren teclado, foco o contraste",
+        type: "spec-terms",
+        severity: "warning",
+        appliesTo: { domains: ["frontend", "mobile", "fullstack"] },
+        params: { terms: ["teclado", "foco", "contraste", "lector de pantalla", "aria", "accesib"] },
+        hint: "A\xF1ade un escenario de uso con teclado, foco visible o contraste suficiente."
+      },
+      {
+        id: "ACC-2",
+        title: "Hay un requisito no funcional medible (AA)",
+        type: "nfr-measurable",
+        severity: "warning",
+        appliesTo: { domains: ["frontend", "mobile", "fullstack"] },
+        hint: "Incluye una regla con un valor medible (contraste 4.5:1, \xE1rea t\xE1ctil 44 px, etc.)."
+      }
+    ]
+  }
+];
+function normalize(text) {
+  return text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+}
+function changeTexts(change) {
+  const delta = change.delta;
+  const requirements = [...delta?.added ?? [], ...delta?.modified ?? []];
+  const spec = requirements.map((requirement) => `${requirement.title}
+${requirement.prose}`).join("\n");
+  const rules = requirements.flatMap((requirement) => requirement.rules.map((rule) => rule.text)).join("\n");
+  const scenarios = requirements.flatMap((requirement) => requirement.scenarios.flatMap((scenario) => [scenario.title, ...scenario.when, ...scenario.then])).join("\n");
+  return { spec, rules, scenarios };
+}
+function hasAnyTerm(text, terms) {
+  const haystack = normalize(text);
+  return terms.some((term) => haystack.includes(normalize(term)));
+}
+function applies(check, change) {
+  const appliesTo = check.appliesTo;
+  if (!appliesTo) return true;
+  const domain = change.meta?.domain ?? "";
+  const lane = change.meta?.lane ?? "standard";
+  if (appliesTo.domains && appliesTo.domains.length > 0 && !appliesTo.domains.includes(domain)) return false;
+  if (appliesTo.lanes && appliesTo.lanes.length > 0 && !appliesTo.lanes.includes(lane)) return false;
+  return true;
+}
+function evaluateCheck(check, change, tasks, verify, config) {
+  const base = { packId: "", checkId: check.id, title: check.title, severity: check.severity };
+  if (!applies(check, change)) {
+    return { ...base, status: "n/a" };
+  }
+  const texts = changeTexts(change);
+  switch (check.type) {
+    case "task-rollback": {
+      const pending = tasks?.blocks.flatMap((block) => block.tasks) ?? [];
+      const tasksWithout = pending.filter((task) => !task.infra && (!task.rollback || task.rollback.trim() === ""));
+      if (pending.length === 0) return { ...base, status: "fail", message: "El cambio no tiene tareas con las que verificar el control", ...check.hint ? { hint: check.hint } : {} };
+      if (tasksWithout.length > 0) {
+        return { ...base, status: "fail", message: `${tasksWithout.length} tarea(s) sin Reversi\xF3n: ${tasksWithout.map((task) => task.id).join(", ")}`, ...check.hint ? { hint: check.hint } : {} };
+      }
+      return { ...base, status: "ok" };
+    }
+    case "evidence-strong": {
+      const evidence = verify?.evidence ?? [];
+      if (evidence.length === 0) return { ...base, status: "fail", message: "Todav\xEDa no hay evidencia registrada", ...check.hint ? { hint: check.hint } : {} };
+      const manual = evidence.filter((entry) => entry.method === "manual" || entry.method === "semi");
+      if (manual.length > 0) {
+        return { ...base, status: "fail", message: `${manual.length} evidencia(s) manual/semi: ${manual.map((entry) => entry.scenario).join(", ")}`, ...check.hint ? { hint: check.hint } : {} };
+      }
+      return { ...base, status: "ok" };
+    }
+    case "spec-terms": {
+      const terms = check.params?.terms ?? [];
+      const ok = hasAnyTerm(`${texts.spec}
+${texts.scenarios}`, terms);
+      return ok ? { ...base, status: "ok" } : { ...base, status: "fail", message: "El cambio no menciona ninguno de los t\xE9rminos esperados", ...check.hint ? { hint: check.hint } : {} };
+    }
+    case "rule-terms": {
+      const terms = check.params?.terms ?? [];
+      const ok = hasAnyTerm(`${texts.rules}
+${texts.scenarios}`, terms);
+      return ok ? { ...base, status: "ok" } : { ...base, status: "fail", message: "Ninguna regla o escenario nombra el control esperado", ...check.hint ? { hint: check.hint } : {} };
+    }
+    case "nfr-measurable": {
+      const measurable = /(\d+(?:[.,]\d+)?)\s*(%|px|ms|s|seg|min|h|d|kb|mb|gb|:1|veces)/i.test(`${texts.rules}
+${texts.scenarios}`);
+      return measurable ? { ...base, status: "ok" } : { ...base, status: "fail", message: "No se encontr\xF3 ning\xFAn valor medible en reglas o escenarios", ...check.hint ? { hint: check.hint } : {} };
+    }
+    case "approval-provider": {
+      return config.gates.approval !== "none" ? { ...base, status: "ok" } : { ...base, status: "fail", message: 'El provider de aprobaci\xF3n est\xE1 en "none"', ...check.hint ? { hint: check.hint } : {} };
+    }
+  }
+}
+async function loadProjectPacks(sddDir) {
+  const dir = path9.join(sddDir, "packs");
+  const diagnostics = [];
+  const packs = [];
+  for (const entry of await listDir(dir)) {
+    if (!/\.ya?ml$/i.test(entry)) continue;
+    const file = path9.join(dir, entry);
+    const raw = await readTextIfExists(file);
+    if (raw === void 0) continue;
+    let data;
+    try {
+      data = parseYaml7(raw);
+    } catch (err) {
+      diagnostics.push(diag("PACK-000", "error", `Pack inv\xE1lido (${entry}): ${err.message}`, { path: file }));
+      continue;
+    }
+    const parsed = packSchema.safeParse(data);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        diagnostics.push(diag("PACK-000", "error", `Pack ${entry} (${issue.path.join(".") || "ra\xEDz"}): ${issue.message}`, { path: file }));
+      }
+      continue;
+    }
+    const value = parsed.data;
+    packs.push({
+      id: value.id,
+      title: value.title,
+      description: value.description,
+      source: "project",
+      checks: value.checks.map((check) => {
+        const built = { id: check.id, title: check.title, type: check.type, severity: check.severity };
+        if (check.applies_to) {
+          const appliesTo = {};
+          if (check.applies_to.domains) appliesTo.domains = check.applies_to.domains;
+          if (check.applies_to.lanes) appliesTo.lanes = check.applies_to.lanes;
+          built.appliesTo = appliesTo;
+        }
+        if (check.params) built.params = check.params;
+        if (check.hint !== void 0) built.hint = check.hint;
+        return built;
+      })
+    });
+  }
+  return { packs, diagnostics };
+}
+async function resolvePacks(sddDir, config) {
+  const { packs: projectPacks, diagnostics } = await loadProjectPacks(sddDir);
+  const byId = /* @__PURE__ */ new Map();
+  for (const pack of BUILTIN_PACKS) byId.set(pack.id, pack);
+  for (const pack of projectPacks) byId.set(pack.id, pack);
+  const active = config.packs.map((id) => byId.get(id)).filter((pack) => pack !== void 0);
+  for (const id of config.packs) {
+    if (!byId.has(id)) {
+      diagnostics.push(diag("PACK-001", "warning", `El pack "${id}" no existe (ni integrado ni en .sdd/packs/)`, { suggestion: "Ejecuta `satlas packs` para ver los disponibles" }));
+    }
+  }
+  return { packs: active, diagnostics };
+}
+function evaluatePacks(packs, change, config) {
+  return packs.map((pack) => {
+    const results = pack.checks.map((check) => {
+      const result = evaluateCheck(check, change, change.tasks, change.verify ?? change.fix, config);
+      return { ...result, packId: pack.id };
+    });
+    const failed = results.filter((result) => result.status === "fail").length;
+    const passed = results.filter((result) => result.status === "ok").length;
+    const evaluated = results.filter((result) => result.status !== "n/a").length;
+    return {
+      pack,
+      status: evaluated === 0 ? "n/a" : failed > 0 ? "fail" : "ok",
+      results,
+      passed,
+      failed
+    };
+  });
+}
+function packFindings(evaluations, change) {
+  const findings = [];
+  for (const evaluation of evaluations) {
+    for (const result of evaluation.results) {
+      if (result.status !== "fail") continue;
+      findings.push(
+        diag(`PACK-${evaluation.pack.id.toUpperCase()}-${result.checkId}`, result.severity, `[${evaluation.pack.title}] ${result.title}${result.message ? `: ${result.message}` : ""}`, {
+          ...result.hint ? { suggestion: result.hint } : {}
+        })
+      );
+    }
+  }
+  void change;
+  return findings;
+}
+
+// src/analyze.ts
+var UI_DOMAINS = /* @__PURE__ */ new Set(["frontend", "mobile", "fullstack"]);
+async function runAnalyze(opts) {
+  const root = path10.resolve(opts.root);
+  const { workspace, config } = await loadWorkspace(root);
+  const change = workspace.changes.find((c) => c.slug === opts.slug);
+  if (!change) {
+    return {
+      slug: opts.slug,
+      status: "blocked",
+      findings: [diag("ATLAS-ANALYZE-000", "error", `No existe el cambio "${opts.slug}"`)],
+      summary: { errors: 1, warnings: 0, infos: 0 },
+      evidence: { done: 0, total: 0 }
+    };
+  }
+  const findings = [...change.diagnostics];
+  const living = /* @__PURE__ */ new Map();
+  for (const spec of workspace.specs) {
+    for (const req of spec.spec.requirements) living.set(req.id, req);
+  }
+  if (change.delta) {
+    findings.push(...lintDelta(change.delta, living, path10.join(change.dir, "spec.md"), { language: config.spec.language }));
+  }
+  const trace = checkTrace({ specs: workspace.specs, change, requireEvidence: false });
+  findings.push(...trace.findings);
+  let waves;
+  if (change.tasks && change.tasks.counts.total > 0) {
+    const plan = planWaves(change.tasks, { maxParallel: config.waves.max_parallel });
+    findings.push(...plan.blocks.flatMap((b) => b.diagnostics));
+    waves = plan.summary;
+  }
+  const lane = change.meta?.lane ?? config.lanes.default;
+  if (lane !== "fix" && !change.planPath) {
+    findings.push(diag("ATLAS-ANALYZE-001", "warning", "El cambio no tiene plan.md (plan t\xE9cnico)", { suggestion: "Ejecuta la fase /satlas-plan" }));
+  }
+  const deltaScenarios = [...change.delta?.added ?? [], ...change.delta?.modified ?? []].flatMap((r) => r.scenarios);
+  const passed = new Set((change.verify?.evidence ?? []).filter((e) => e.result === "pass").map((e) => e.scenario));
+  const evidence = { done: deltaScenarios.filter((s) => passed.has(s.id)).length, total: deltaScenarios.length };
+  let mockups;
+  const domain = change.meta?.domain ?? "";
+  if (UI_DOMAINS.has(domain)) {
+    const check = await checkMockups(root, opts.slug, change);
+    findings.push(...check.findings);
+    mockups = { screens: check.manifest?.screens.length ?? 0, stale: check.stale };
+  }
+  let packs;
+  if (config.packs.length > 0) {
+    const resolved = await resolvePacks(workspace.sddDir, config);
+    findings.push(...resolved.diagnostics);
+    const evaluations = evaluatePacks(resolved.packs, change, config);
+    findings.push(...packFindings(evaluations, change));
+    packs = evaluations.map((evaluation) => ({
+      id: evaluation.pack.id,
+      title: evaluation.pack.title,
+      status: evaluation.status,
+      passed: evaluation.passed,
+      failed: evaluation.failed
+    }));
+  }
+  const summary = countBySeverity(findings);
+  const status = summary.errors > 0 ? "blocked" : summary.warnings > 5 ? "passed_with_debt" : "passed";
+  const result = { slug: opts.slug, status, findings, summary, evidence };
+  if (waves) result.waves = waves;
+  if (mockups) result.mockups = mockups;
+  if (packs) result.packs = packs;
+  if (opts.write !== false) {
+    const file = path10.join(change.dir, "analyze.md");
+    await writeText(file, renderAnalyze(change, result, (opts.now ?? /* @__PURE__ */ new Date()).toISOString()));
+    result.path = file;
+  }
+  return result;
+}
+function renderAnalyze(change, result, generatedAt) {
+  const lines = [];
+  lines.push(`# An\xE1lisis \u2014 ${change.meta?.title ?? change.slug}`);
+  lines.push("");
+  lines.push(`- Generado: ${generatedAt}`);
+  lines.push(`- Estado: **${result.status}**`);
+  lines.push(`- Evidencia: ${result.evidence.done}/${result.evidence.total} escenarios`);
+  if (result.waves) lines.push(`- Olas: ${result.waves.blocks} bloque(s), ${result.waves.waves} ola(s), ${result.waves.tasks} tarea(s)`);
+  if (result.mockups) lines.push(`- Mockups: ${result.mockups.screens} pantalla(s)${result.mockups.stale ? " (desactualizados)" : ""}`);
+  lines.push("");
+  if (result.packs && result.packs.length > 0) {
+    lines.push("## Packs de cumplimiento");
+    lines.push("");
+    lines.push("| Pack | Estado | Controles |");
+    lines.push("|---|---|---|");
+    for (const pack of result.packs) {
+      lines.push(`| ${pack.title} (\`${pack.id}\`) | ${pack.status} | ${pack.passed} ok \xB7 ${pack.failed} con falla |`);
+    }
+    lines.push("");
+  }
+  lines.push(`## Hallazgos (${result.summary.errors} errores, ${result.summary.warnings} avisos)`);
+  lines.push("");
+  if (result.findings.length === 0) {
+    lines.push("Sin hallazgos.");
+  } else {
+    lines.push("| C\xF3digo | Severidad | Mensaje | Ubicaci\xF3n |");
+    lines.push("|---|---|---|---|");
+    for (const finding of result.findings) {
+      const location = finding.path ? `${finding.path}${finding.line ? `:${finding.line}` : ""}` : "\u2014";
+      lines.push(`| ${finding.code} | ${finding.severity} | ${finding.message.replace(/\|/g, "\\|")} | ${location} |`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/metrics.ts
+import path11 from "path";
+async function collectMetrics(root, now = /* @__PURE__ */ new Date()) {
+  const resolved = path11.resolve(root);
+  const { workspace, config } = await loadWorkspace(resolved);
+  const approvals = await loadApprovals(workspace.sddDir);
+  const living = /* @__PURE__ */ new Map();
+  for (const spec of workspace.specs) {
+    for (const requirement of spec.spec.requirements) living.set(requirement.id, requirement);
+  }
+  const changes = [];
+  const evidenceByMethod = {};
+  const wipByState = {};
+  const blocked = [];
+  for (const change of workspace.changes) {
+    const deltaContent = await readDelta(change);
+    const approval = verifyApproval(change, approvals.byArtifact, config, deltaContent);
+    const findings = [];
+    if (change.delta) findings.push(...lintDelta(change.delta, living, path11.join(change.dir, "spec.md"), { language: config.spec.language }));
+    const trace = checkTrace({
+      specs: workspace.specs,
+      change,
+      requireEvidence: config.gates.verify.mode !== "off" && config.gates.verify.require_evidence
+    });
+    findings.push(...trace.findings);
+    const state = deriveState({ change, cfg: config, approval, blockingFindings: change.delta ? countBySeverity(findings).errors : 0 });
+    const scenarios = [...change.delta?.added ?? [], ...change.delta?.modified ?? []].flatMap((req) => req.scenarios);
+    const passed = scenarios.filter((scenario) => (change.verify?.evidence ?? []).some((e) => e.scenario === scenario.id && e.result === "pass"));
+    for (const entry of [...change.verify?.evidence ?? [], ...change.fix?.evidence ?? []]) {
+      evidenceByMethod[entry.method] = (evidenceByMethod[entry.method] ?? 0) + 1;
+    }
+    const summary = countBySeverity(findings);
+    const ageDays = change.meta?.created ? Math.max(0, Math.round((now.getTime() - Date.parse(change.meta.created)) / 864e5)) : void 0;
+    const metric = {
+      slug: change.slug,
+      ...change.meta?.title !== void 0 ? { title: change.meta.title } : {},
+      ...change.meta?.domain !== void 0 ? { domain: change.meta.domain } : {},
+      lane: change.meta?.lane ?? config.lanes.default,
+      state: state.state,
+      stateLabel: stateLabel(state.state),
+      tasksDone: state.progress.tasksDone,
+      tasksTotal: state.progress.tasksTotal,
+      scenariosTotal: scenarios.length,
+      scenariosPassed: passed.length,
+      findingsErrors: summary.errors,
+      findingsWarnings: summary.warnings,
+      blockedBy: state.blockedBy,
+      next: state.nextAction.command,
+      ...ageDays !== void 0 ? { ageDays } : {}
+    };
+    changes.push(metric);
+    const bucket = wipByState[state.state] ?? { label: stateLabel(state.state), count: 0 };
+    bucket.count += 1;
+    wipByState[state.state] = bucket;
+    if (state.blockedBy.length > 0) blocked.push({ slug: change.slug, reason: state.blockedBy.join("; ") });
+  }
+  changes.sort((a, b) => a.slug.localeCompare(b.slug));
+  const ages = changes.map((change) => change.ageDays).filter((age) => age !== void 0);
+  const averageDays = ages.length > 0 ? Math.round(ages.reduce((acc, age) => acc + age, 0) / ages.length * 10) / 10 : void 0;
+  const oldestChange = changes.filter((change) => change.ageDays !== void 0).sort((a, b) => (b.ageDays ?? 0) - (a.ageDays ?? 0))[0];
+  const agingBuckets = [
+    { label: "0-3 d\xEDas", value: ages.filter((age) => age <= 3).length },
+    { label: "4-7 d\xEDas", value: ages.filter((age) => age >= 4 && age <= 7).length },
+    { label: "8-14 d\xEDas", value: ages.filter((age) => age >= 8 && age <= 14).length },
+    { label: "15+ d\xEDas", value: ages.filter((age) => age >= 15).length }
+  ];
+  const laneCounts = /* @__PURE__ */ new Map();
+  for (const change of changes) laneCounts.set(change.lane, (laneCounts.get(change.lane) ?? 0) + 1);
+  const byLane = [...laneCounts.entries()].map(([label, value]) => ({ label, value })).sort((a, b) => b.value - a.value);
+  const attention = [];
+  for (const change of changes) {
+    if (change.blockedBy.length > 0) {
+      attention.push({ slug: change.slug, kind: "blocked", detail: change.blockedBy.join("; ") });
+      continue;
+    }
+    if (change.ageDays !== void 0 && change.ageDays >= 15) {
+      attention.push({ slug: change.slug, kind: "aging", detail: `lleva ${change.ageDays} d\xEDas sin cerrarse` });
+      continue;
+    }
+    if (change.state === "built" && change.scenariosTotal > 0 && change.scenariosPassed < change.scenariosTotal) {
+      attention.push({ slug: change.slug, kind: "missing-evidence", detail: `evidencia ${change.scenariosPassed}/${change.scenariosTotal}` });
+    }
+  }
+  const archiveDir = path11.join(workspace.sddDir, "changes", "archive");
+  const archivedEntries = await listDirs(archiveDir);
+  const throughputByMonth = {};
+  for (const entry of archivedEntries) {
+    const month = /^(\d{4}-\d{2})/.exec(entry)?.[1];
+    if (month) throughputByMonth[month] = (throughputByMonth[month] ?? 0) + 1;
+  }
+  const totals = {
+    changes: changes.length,
+    tasks: changes.reduce((acc, c) => acc + c.tasksTotal, 0),
+    tasksDone: changes.reduce((acc, c) => acc + c.tasksDone, 0),
+    scenarios: changes.reduce((acc, c) => acc + c.scenariosTotal, 0),
+    scenariosPassed: changes.reduce((acc, c) => acc + c.scenariosPassed, 0),
+    errors: changes.reduce((acc, c) => acc + c.findingsErrors, 0),
+    warnings: changes.reduce((acc, c) => acc + c.findingsWarnings, 0),
+    archived: archivedEntries.length
+  };
+  return {
+    generatedAt: now.toISOString(),
+    project: config.project.name,
+    root: resolved,
+    changes,
+    totals,
+    wipByState,
+    throughputByMonth,
+    evidenceByMethod,
+    blocked,
+    aging: {
+      ...averageDays !== void 0 ? { averageDays } : {},
+      ...oldestChange && oldestChange.ageDays !== void 0 ? { oldest: { slug: oldestChange.slug, ageDays: oldestChange.ageDays } } : {},
+      buckets: agingBuckets
+    },
+    byLane,
+    attention
+  };
+}
+async function readDelta(change) {
+  const { readTextIfExists: readTextIfExists2 } = await import("./fsx-VF2P7ALA.js");
+  return readTextIfExists2(path11.join(change.dir, "spec.md"));
+}
+
+// src/present.ts
+import path12 from "path";
+import { escapeHtml, inlineMarkdown, renderMarkdown as renderRich } from "@specatlas/render";
+import { defaultTokens, renderDocument, renderStyles } from "@specatlas/render";
+async function generatePresentation(opts) {
+  const root = path12.resolve(opts.root);
+  const { workspace, config } = await loadWorkspace(root);
+  const language = config.project.language;
+  const change = workspace.changes.find((c) => c.slug === opts.slug);
+  if (!change) {
+    return { slug: opts.slug, diagnostics: [diag("ATLAS-PRESENT-000", "error", `No existe el cambio "${opts.slug}"`)] };
+  }
+  if (!change.delta) {
+    return { slug: opts.slug, diagnostics: [diag("ATLAS-PRESENT-001", "error", `El cambio "${opts.slug}" no tiene spec.md (delta)`)] };
+  }
+  const deltaPath = path12.join(change.dir, "spec.md");
+  const deltaContent = await readTextIfExists(deltaPath) ?? "";
+  const hash = artifactHash(deltaContent);
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const presentationDir = path12.join(change.dir, "presentation");
+  const mockupsCopyDir = path12.join(presentationDir, "mockups");
+  await ensureDir(presentationDir);
+  const mockupInfo = await copyMockups(root, change, mockupsCopyDir);
+  const proposalRaw = await readTextIfExists(path12.join(change.dir, "proposal.md"));
+  const proposalBody = proposalRaw ? parseFrontmatter(proposalRaw).body : "";
+  const labels = labelsFor(language);
+  const html = page({
+    language,
+    labels,
+    title: change.meta?.title ?? change.slug,
+    domain: change.meta?.domain ?? "\xE2\u20AC\u201D",
+    lane: change.meta?.lane ?? config.lanes.default,
+    project: config.project.name,
+    version: change.delta.sectionsFound.length,
+    hash,
+    generatedAt: now.toISOString(),
+    proposalHtml: proposalBody ? renderMarkdown(proposalBody) : `<p><em>${labels.noProposal}</em></p>`,
+    requirements: change.delta ? [...change.delta.added.map((r) => ({ req: r, kind: "added" })), ...change.delta.modified.map((r) => ({ req: r, kind: "modified" }))] : [],
+    evidence: new Map((change.verify?.evidence ?? []).map((e) => [e.scenario, e.result])),
+    mockups: mockupInfo.screens,
+    screenshots: mockupInfo.screenshots,
+    approveHint: `satlas approve ${change.slug} --by "<nombre>" --channel presentation`
+  });
+  const outFile = path12.join(presentationDir, "index.html");
+  await writeText(outFile, html);
+  return { slug: change.slug, path: outFile, hash, diagnostics: mockupInfo.diagnostics };
+}
+async function copyMockups(root, change, destDir) {
+  const diagnostics = [];
+  const dir = mockupsDir(root, change.slug);
+  const { manifest } = await readMockupManifest(root, change.slug);
+  if (!manifest || !await exists(dir)) return { screens: [], screenshots: [], diagnostics };
+  await ensureDir(destDir);
+  const screens = [];
+  for (const screen of manifest.screens) {
+    const src = path12.join(dir, screen.file);
+    if (!await exists(src)) {
+      diagnostics.push(diag("ATLAS-PRESENT-002", "warning", `El mockup ${screen.file} no existe y no se incluir\xC3\xA1`, { path: src }));
+      continue;
+    }
+    await copyFile(src, path12.join(destDir, screen.file));
+    screens.push({
+      id: screen.id,
+      title: screen.title ?? screen.id,
+      file: `mockups/${screen.file}`,
+      platform: manifest.platform,
+      illustrates: screen.illustrates ?? []
+    });
+  }
+  const screenshots = [];
+  const shotsDir = path12.join(dir, "screens");
+  if (await exists(shotsDir)) {
+    await ensureDir(path12.join(destDir, "screens"));
+    const { listDir: listDir4 } = await import("./fsx-VF2P7ALA.js");
+    for (const file of await listDir4(shotsDir)) {
+      if (!/\.(png|jpe?g|webp)$/i.test(file)) continue;
+      await copyFile(path12.join(shotsDir, file), path12.join(destDir, "screens", file));
+      screenshots.push(`mockups/screens/${file}`);
+    }
+  }
+  return { screens, screenshots, diagnostics };
+}
+function labelsFor(language) {
+  if (language === "en") {
+    return {
+      kicker: "Proposal",
+      summary: "Business summary",
+      criteria: "Acceptance criteria",
+      requirements: "Requirements and scenarios",
+      mockups: "Mockups",
+      approve: "Approval",
+      approveText: "This proposal is approved by signing the spec (hash + author). Any later change invalidates the signature.",
+      command: "Command",
+      hash: "Hash",
+      generated: "Generated",
+      noProposal: "The proposal is empty.",
+      added: "added",
+      modified: "modified",
+      scenario: "Scenario",
+      evidence: "Evidence",
+      pending: "pending",
+      noMockups: "No mockups declared for this change.",
+      screenshots: "Screenshots"
+    };
+  }
+  return {
+    kicker: "Propuesta",
+    summary: "Resumen de negocio",
+    criteria: "Criterios de aceptaci\xC3\xB3n",
+    requirements: "Requisitos y escenarios",
+    mockups: "Mockups",
+    approve: "Aprobaci\xC3\xB3n",
+    approveText: "Esta propuesta se aprueba firmando la spec (hash + autor). Cualquier cambio posterior invalida la firma.",
+    command: "Comando",
+    hash: "Hash",
+    generated: "Generado",
+    noProposal: "La propuesta est\xC3\xA1 vac\xC3\xADa.",
+    added: "agregado",
+    modified: "modificado",
+    scenario: "Escenario",
+    evidence: "Evidencia",
+    pending: "pendiente",
+    noMockups: "Este cambio no declara mockups.",
+    screenshots: "Capturas"
+  };
+}
+var CSS = `
+:root { --bg:#f8fafc; --card:#ffffff; --ink:#0f172a; --muted:#64748b; --line:#e2e8f0; --accent:#0f766e; --accent-soft:#ccfbf1; --warn:#b45309; --ok:#15803d; }
+@media (prefers-color-scheme: dark) { :root { --bg:#0b1220; --card:#111a2c; --ink:#e2e8f0; --muted:#94a3b8; --line:#1e293b; --accent:#2dd4bf; --accent-soft:#134e4a; --warn:#f59e0b; --ok:#4ade80; } }
+* { box-sizing: border-box; }
+body { margin:0; background:var(--bg); color:var(--ink); font: 16px/1.6 ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; }
+.wrap { max-width: 980px; margin: 0 auto; padding: 32px 20px 80px; }
+.hero { background: linear-gradient(135deg, var(--accent), #0ea5e9); color: white; border-radius: 18px; padding: 28px; margin-bottom: 28px; }
+.hero h1 { margin: 6px 0 10px; font-size: 30px; line-height: 1.2; }
+.kicker { text-transform: uppercase; letter-spacing: .12em; font-size: 12px; opacity: .9; margin: 0; }
+.meta { margin: 0; font-size: 13px; opacity: .95; }
+section { background: var(--card); border: 1px solid var(--line); border-radius: 14px; padding: 22px; margin-bottom: 22px; }
+section h2 { margin-top: 0; font-size: 20px; }
+h3 { margin-bottom: 4px; }
+h4 { margin: 14px 0 6px; color: var(--muted); font-weight: 600; }
+table { width: 100%; border-collapse: collapse; font-size: 14px; }
+th, td { border: 1px solid var(--line); padding: 8px 10px; text-align: left; vertical-align: top; }
+th { background: color-mix(in srgb, var(--accent-soft) 50%, transparent); }
+code { background: color-mix(in srgb, var(--line) 60%, transparent); padding: 1px 5px; border-radius: 6px; font-size: 13px; }
+pre { background: #0b1220; color: #e2e8f0; padding: 14px; border-radius: 10px; overflow:auto; font-size: 13px; }
+pre code { background: transparent; color: inherit; }
+.badge { display:inline-block; font-size: 11px; text-transform: uppercase; letter-spacing:.08em; background: var(--accent-soft); color: var(--accent); border-radius: 999px; padding: 2px 10px; margin-left: 8px; }
+.req { border-top: 1px solid var(--line); padding-top: 16px; margin-top: 16px; }
+.req:first-of-type { border-top: 0; margin-top: 0; padding-top: 0; }
+.rules { color: var(--muted); font-size: 14px; }
+.scenario { margin: 8px 0 8px 0; }
+.when { color: var(--muted); }
+.then { font-weight: 600; }
+.pill { font-size: 12px; padding: 1px 8px; border-radius: 999px; border: 1px solid var(--line); }
+.pill.pass { color: var(--ok); border-color: var(--ok); }
+.pill.fail { color: #dc2626; border-color: #dc2626; }
+.pill.skipped, .pill.pending { color: var(--warn); border-color: var(--warn); }
+.mockups { display:grid; gap: 18px; }
+.mockup { border: 1px solid var(--line); border-radius: 12px; overflow: hidden; }
+.mockup header { padding: 10px 14px; border-bottom: 1px solid var(--line); font-weight: 600; font-size: 14px; }
+.mockup iframe { width: 100%; height: 560px; border: 0; background: white; }
+.mockup.phone iframe { max-width: 420px; margin: 0 auto; display:block; }
+.grid-shots { display:grid; grid-template-columns: repeat(auto-fill, minmax(220px, 1fr)); gap: 12px; }
+.grid-shots img { width: 100%; border: 1px solid var(--line); border-radius: 10px; }
+footer { color: var(--muted); font-size: 13px; text-align:center; }
+.callout { border-left: 4px solid var(--accent); background: color-mix(in srgb, var(--accent-soft) 35%, transparent); padding: 12px 14px; border-radius: 8px; }
+@media print { body { background: white; } section { break-inside: avoid; } .hero { background: #0f766e; } }
+`.trim();
+function page(input) {
+  const l = input.labels;
+  const reqHtml = input.requirements.map(({ req, kind }) => {
+    const rules = req.rules.map((r) => `<li><code>${esc(r.id)}</code> \xE2\u20AC\u201D ${inline(r.text)}</li>`).join("");
+    const scenarios = req.scenarios.map((s) => {
+      const when = s.when.map((w) => `<div class="when">CUANDO ${inline(w)}</div>`).join("");
+      const then = s.then.map((t) => `<div class="then">ENTONCES ${inline(t)}</div>`).join("");
+      return `<div class="scenario"><h4>${esc(s.id)} \xE2\u20AC\u201D ${esc(s.title)}</h4>${when}${then}</div>`;
+    }).join("");
+    return `<div class="req"><h3>${esc(req.id)} \xE2\u20AC\u201D ${esc(req.title)}<span class="badge">${kind === "added" ? l.added : l.modified}</span></h3><p>${inline(req.prose)}</p>${rules ? `<ul class="rules">${rules}</ul>` : ""}${scenarios}</div>`;
+  }).join("");
+  const criteriaRows = input.requirements.flatMap(({ req }) => req.scenarios).map((s) => {
+    const status = input.evidence.get(s.id);
+    const cls = status ?? "pending";
+    const label = status ?? l.pending;
+    return `<tr><td><code>${esc(s.id)}</code></td><td>${esc(s.title)}</td><td><span class="pill ${cls}">${esc(label)}</span></td></tr>`;
+  }).join("");
+  const mockupHtml = input.mockups.length === 0 ? `<p><em>${l.noMockups}</em></p>` : `<div class="mockups">${input.mockups.map(
+    (m) => `<div class="mockup ${m.platform === "mobile" ? "phone" : ""}"><header>${esc(m.title)} \xE2\u20AC\u201D ${esc(m.file)}</header><iframe src="${esc(m.file)}" loading="lazy" title="${esc(m.title)}"></iframe></div>`
+  ).join("")}</div>`;
+  const shotsHtml = input.screenshots.length === 0 ? "" : `<h3>${l.screenshots}</h3><div class="grid-shots">${input.screenshots.map((s) => `<img src="${esc(s)}" alt="${esc(s)}" loading="lazy">`).join("")}</div>`;
+  return `<!doctype html>
+<html lang="${input.language}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>${esc(l.kicker)} \xE2\u20AC\u201D ${esc(input.title)}</title>
+<style>${CSS}</style>
+</head>
+<body>
+<div class="wrap">
+  <header class="hero">
+    <p class="kicker">${esc(l.kicker)} \xC2\xB7 ${esc(input.domain)} \xC2\xB7 ${esc(input.lane)}</p>
+    <h1>${esc(input.title)}</h1>
+    <p class="meta">${esc(input.project)} \xC2\xB7 ${esc(l.hash)} ${esc(shortHash(input.hash))} \xC2\xB7 ${esc(l.generated)} ${esc(input.generatedAt)}</p>
+  </header>
+
+  <section>
+    <h2>${esc(l.summary)}</h2>
+    ${input.proposalHtml}
+  </section>
+
+  <section>
+    <h2>${esc(l.criteria)}</h2>
+    <table><thead><tr><th>ID</th><th>${esc(l.scenario)}</th><th>${esc(l.evidence)}</th></tr></thead><tbody>${criteriaRows}</tbody></table>
+  </section>
+
+  <section>
+    <h2>${esc(l.requirements)}</h2>
+    ${reqHtml}
+  </section>
+
+  <section>
+    <h2>${esc(l.mockups)}</h2>
+    ${mockupHtml}
+    ${shotsHtml}
+  </section>
+
+  <section>
+    <h2>${esc(l.approve)}</h2>
+    <div class="callout">${esc(l.approveText)}</div>
+    <p>${esc(l.command)}: <code>${esc(input.approveHint)}</code></p>
+  </section>
+
+  <footer>SpecAtlas \xC2\xB7 ${esc(input.project)} \xC2\xB7 ${esc(input.generatedAt)}</footer>
+</div>
+</body>
+</html>
+`;
+}
+function esc(text) {
+  return escapeHtml(text);
+}
+function inline(text) {
+  return inlineMarkdown(text);
+}
+function renderMarkdown(markdown) {
+  return renderRich(markdown, { highlight: true });
+}
+
+// src/adopt.ts
+import path13 from "path";
+var COMMON_ROOTS = ["src", "app", "lib", "modules", "services", "packages", "api", "features", "domain", "internal", "components"];
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "build", "out", "coverage", ".git", ".sdd", ".opencode", ".claude", "test", "tests", "__tests__", "e2e", "docs", "scripts", "assets", "public", "migrations", "vendor", "bin", "obj"]);
+var SOURCE_EXT = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".cs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".go",
+  ".rb",
+  ".php",
+  ".rs",
+  ".swift",
+  ".dart",
+  ".vue",
+  ".svelte",
+  ".sql",
+  ".cshtml",
+  ".razor",
+  ".vb",
+  ".fs",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".scala",
+  ".ex",
+  ".exs",
+  ".clj",
+  ".lua",
+  ".r",
+  ".m",
+  ".mm",
+  ".pl",
+  ".groovy"
+]);
+async function adoptWorkspace(opts) {
+  const root = path13.resolve(opts.root);
+  const dryRun = opts.dryRun ?? false;
+  const diagnostics = [];
+  const sddDir = path13.join(root, ".sdd");
+  if (!await exists(path13.join(sddDir, "config.yaml"))) {
+    return {
+      root,
+      domains: [],
+      createdSpecs: [],
+      diagnostics: [diag("ATLAS-ADOPT-001", "error", "No hay .sdd/config.yaml: inicializa el proyecto con `satlas init` antes de adoptar", { path: sddDir })],
+      dryRun
+    };
+  }
+  const { config } = await loadConfig(sddDir);
+  const files = await walkFiles(root, { skipDirs: [...SKIP_DIRS] });
+  const inventoried = files.map((f) => toPosix(path13.relative(root, f.path)));
+  const relative = inventoried.filter((f) => SOURCE_EXT.has(path13.extname(f).toLowerCase()));
+  if (relative.length === 0) {
+    diagnostics.push(diag("ATLAS-ADOPT-002", "warning", "No se encontraron archivos de c\xF3digo para inventariar", { path: root, suggestion: "A\xF1ade el dominio a mano con --domains <nombre>" }));
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const file of relative) {
+    const domain = inferDomain(file);
+    if (!domain) continue;
+    const list = counts.get(domain) ?? [];
+    list.push(file);
+    counts.set(domain, list);
+  }
+  if (counts.size === 0 && relative.length > 0) {
+    const fallback = await fallbackDomainName(root, config.project.name);
+    counts.set(fallback, relative);
+  }
+  const requested = opts.domains?.map((d) => d.toLowerCase());
+  let domainNames = [...counts.keys()].filter((name) => requested ? requested.includes(name) : true);
+  if (requested) {
+    for (const name of requested) if (!counts.has(name)) domainNames.push(name);
+  }
+  if (domainNames.length === 0) domainNames = ["general"];
+  const profiles = await loadProjectProfiles(root, opts.profilesDirs ?? []);
+  const detection = profiles.length > 0 ? await detectProfiles(root, profiles) : void 0;
+  const domains = [];
+  const createdSpecs = [];
+  for (const name of domainNames.sort()) {
+    const domainFiles = (counts.get(name) ?? []).sort();
+    const existingSpec = await exists(path13.join(sddDir, "specs", name, "spec.md"));
+    domains.push({ name, files: domainFiles.length, samples: domainFiles.slice(0, 8), existingSpec });
+    if (existingSpec) {
+      diagnostics.push(diag("ATLAS-ADOPT-003", "info", `La spec de "${name}" ya existe; se conserva`, { path: path13.join(sddDir, "specs", name, "spec.md") }));
+      continue;
+    }
+    const specPath = path13.join(sddDir, "specs", name, "spec.md");
+    if (!dryRun) {
+      await writeText(specPath, baselineSpec(name, domainFiles));
+      createdSpecs.push(specPath);
+    } else {
+      createdSpecs.push(specPath);
+    }
+  }
+  const reportPath = path13.join(sddDir, "adopt-report.md");
+  if (!dryRun) {
+    await writeText(reportPath, adoptReport({ root, config, domains, detection: detection?.best, language: config.project.language, files: relative.length, inventoried: inventoried.length, now: opts.now ?? /* @__PURE__ */ new Date() }));
+  }
+  return {
+    root,
+    domains,
+    createdSpecs,
+    reportPath,
+    ...detection?.best ? { stack: { name: detection.best.name, score: detection.best.score } } : {},
+    diagnostics,
+    dryRun
+  };
+}
+async function loadProjectProfiles(root, dirs) {
+  const out = [];
+  for (const dir of dirs) {
+    if (!await exists(dir)) continue;
+    out.push(...await loadProfilesFromDir(dir));
+  }
+  const custom = path13.join(root, ".sdd", "profiles", "custom");
+  if (await exists(custom)) out.push(...await loadProfilesFromDir(custom));
+  return out;
+}
+async function fallbackDomainName(root, projectName) {
+  const pkg = await readTextIfExists(path13.join(root, "package.json"));
+  if (pkg) {
+    try {
+      const data = JSON.parse(pkg);
+      if (typeof data.name === "string" && data.name.trim() !== "") {
+        return slugify(data.name.replace(/^@[^/]+\//, ""));
+      }
+    } catch {
+    }
+  }
+  return slugify(projectName) || "general";
+}
+function slugify(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function inferDomain(file) {
+  const parts = file.split("/");
+  if (parts.length < 2) return void 0;
+  const [first, second] = parts;
+  if (first && COMMON_ROOTS.includes(first) && second && parts.length > 2) {
+    if (isSourceLike(second)) return void 0;
+    return second.toLowerCase();
+  }
+  if (parts.length === 2 && first && isSourceLike(first)) return first.replace(/\.[^.]+$/, "").toLowerCase();
+  if (parts.length >= 3 && first === "packages" && second) return second.toLowerCase();
+  return void 0;
+}
+function isSourceLike(name) {
+  return /\.(ts|tsx|js|jsx|py|cs|java|go|rb|php|rs|kt|swift|mjs|cjs)$/i.test(name);
+}
+function baselineSpec(domain, files) {
+  const title = domain.charAt(0).toUpperCase() + domain.slice(1);
+  const anchors = files.slice(0, 40);
+  const lines = [];
+  lines.push("---");
+  lines.push(`domain: ${domain}`);
+  lines.push(`title: ${title}`);
+  lines.push("version: 1");
+  lines.push(`updated: ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}`);
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${title}`);
+  lines.push("");
+  lines.push("> Spec baseline generada por `satlas adopt` a partir del c\xF3digo existente.");
+  lines.push("> Los requisitos deben derivarse con el agente y el usuario (fase /satlas-adopt) y plegarse con `satlas archive`.");
+  lines.push("");
+  lines.push("## Anclas de implementaci\xF3n");
+  lines.push("");
+  for (const file of anchors) lines.push(`- ${file}`);
+  if (files.length > anchors.length) lines.push(`- \u2026 (${files.length - anchors.length} archivos m\xE1s)`);
+  lines.push("");
+  return lines.join("\n");
+}
+function adoptReport(input) {
+  const es = input.language !== "en";
+  const lines = [];
+  lines.push(es ? "# Adopci\xF3n (brownfield)" : "# Adoption (brownfield)");
+  lines.push("");
+  lines.push(es ? `- Proyecto: ${input.config.project.name}` : `- Project: ${input.config.project.name}`);
+  lines.push(es ? `- Generado: ${input.now.toISOString()}` : `- Generated: ${input.now.toISOString()}`);
+  lines.push(es ? `- Archivos de c\xF3digo inventariados: ${input.files} (de ${input.inventoried} archivos totales)` : `- Inventoried source files: ${input.files} (of ${input.inventoried} total files)`);
+  if (input.detection) lines.push(es ? `- Stack detectado: ${input.detection.name} (${input.detection.score} puntos)` : `- Detected stack: ${input.detection.name} (${input.detection.score})`);
+  lines.push("");
+  lines.push(es ? "## Dominios candidatos" : "## Candidate domains");
+  lines.push("");
+  lines.push(es ? "| Dominio | Archivos | Spec | Ejemplos |" : "| Domain | Files | Spec | Samples |");
+  lines.push("|---|---|---|---|");
+  for (const domain of input.domains) {
+    lines.push(`| ${domain.name} | ${domain.files} | ${domain.existingSpec ? es ? "existente" : "existing" : es ? "creada" : "created"} | ${domain.samples.slice(0, 3).join("<br>") || "\u2014"} |`);
+  }
+  lines.push("");
+  lines.push(es ? "## Siguiente paso" : "## Next step");
+  lines.push("");
+  if (es) {
+    lines.push("1. Ejecuta la fase `/satlas-adopt` por dominio: el agente lee las anclas y el c\xF3digo, entrevista al usuario y redacta los requisitos AS-IS.");
+    lines.push("2. Crea el cambio con `satlas new adopt-<dominio> --domain <dominio>` y escribe el delta con los requisitos y escenarios del comportamiento actual.");
+    lines.push("3. `satlas validate --change adopt-<dominio>` hasta quedar sin errores y pliega con `satlas archive adopt-<dominio> --yes`.");
+    lines.push("4. Repite por dominio. La adopci\xF3n documenta lo que existe: no requiere tareas ni verificaci\xF3n.");
+  } else {
+    lines.push("1. Run the `/satlas-adopt` phase per domain: the agent reads anchors and code, interviews the user and drafts AS-IS requirements.");
+    lines.push("2. Create the change with `satlas new adopt-<domain> --domain <domain>` and write the delta with current behaviour.");
+    lines.push("3. `satlas validate --change adopt-<domain>` until clean and fold with `satlas archive adopt-<domain> --yes`.");
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/init.ts
+import path14 from "path";
+async function initWorkspace(opts) {
+  const root = path14.resolve(opts.root);
+  const sddDir = path14.join(root, ".sdd");
+  const diagnostics = [];
+  const created = [];
+  if (await exists(path14.join(sddDir, "config.yaml"))) {
+    return {
+      sddDir,
+      created,
+      diagnostics: [diag("ATLAS-INIT-001", "error", "El proyecto ya est\xE1 inicializado (.sdd/config.yaml existe)", { path: sddDir, suggestion: "No hace falta volver a ejecutar `satlas init`" })]
+    };
+  }
+  created.push(...await ensureSddDirs(sddDir));
+  const language = opts.language ?? "es";
+  const cfg = defaultConfig({ name: opts.name, language });
+  cfg.project.name = opts.name ?? path14.basename(root);
+  await writeConfig(sddDir, cfg);
+  created.push(path14.join(sddDir, "config.yaml"));
+  const templates = templatesFor(language);
+  await writeText(path14.join(sddDir, "constitution.md"), templates.constitution);
+  created.push(path14.join(sddDir, "constitution.md"));
+  await writeText(path14.join(sddDir, "glossary.md"), templates.glossary);
+  created.push(path14.join(sddDir, "glossary.md"));
+  const detected = await detectIfPossible(root, opts.profilesDir);
+  if (detected) {
+    const yaml = detectionToYaml(detected, (opts.now ?? /* @__PURE__ */ new Date()).toISOString());
+    await writeText(path14.join(sddDir, "profiles", "detected.yaml"), yaml);
+    created.push(path14.join(sddDir, "profiles", "detected.yaml"));
+    if (detected.best) {
+      diagnostics.push(diag("ATLAS-INIT-002", "info", `Stack detectado: ${detected.best.displayName} (${detected.best.score} puntos)`, { suggestion: "Revisa .sdd/profiles/detected.yaml" }));
+    } else {
+      diagnostics.push(diag("ATLAS-INIT-003", "info", "No se detect\xF3 un stack conocido: se usar\xE1 el perfil gen\xE9rico", { suggestion: "Crea un perfil propio con `satlas profile` (F2) o edita .sdd/profiles/custom/" }));
+    }
+  }
+  await writeText(path14.join(sddDir, "INDEX.md"), initialIndex(language, cfg.project.name));
+  created.push(path14.join(sddDir, "INDEX.md"));
+  if (opts.local) {
+    const gitignore = path14.join(root, ".gitignore");
+    const current = await readTextIfExists(gitignore) ?? "";
+    if (!/(^|\n)\.sdd\/?(\n|$)/.test(current)) {
+      const next = current.endsWith("\n") || current === "" ? `${current}.sdd/
+` : `${current}
+.sdd/
+`;
+      await writeText(gitignore, next);
+      created.push(gitignore);
+    }
+  }
+  return detected ? { sddDir, created, detected, diagnostics } : { sddDir, created, diagnostics };
+}
+async function detectIfPossible(root, profilesDir) {
+  if (!profilesDir) return void 0;
+  if (!await exists(profilesDir)) return void 0;
+  const profiles = await loadProfilesFromDir(profilesDir);
+  if (profiles.length === 0) return void 0;
+  return detectProfiles(root, profiles);
+}
+function initialIndex(language, projectName) {
+  const es = language !== "en";
+  return `# \xCDndice \u2014 ${projectName}
+
+${es ? "> Generado por SpecAtlas. Las specs vivas y los cambios se listan aqu\xED a medida que existan." : "> Generated by SpecAtlas."}
+
+${es ? "## Specs vivas\n\n_Sin specs todav\xEDa._" : "## Living specs\n\n_No specs yet._"}
+
+${es ? "## Cambios activos\n\n_Sin cambios activos._" : "## Active changes\n\n_No active changes._"}
+
+${es ? "## Archivados\n\n0 cambio(s) en `changes/archive/`." : "## Archived\n\n0 change(s)."}
+`;
+}
+
+// src/new.ts
+import path15 from "path";
+var SLUG_RE = /^[a-z0-9][a-z0-9-]{1,49}$/;
+async function createChange(opts) {
+  const diagnostics = [];
+  const slug = opts.slug.trim().toLowerCase();
+  const language = opts.language ?? opts.cfg?.project.language ?? "es";
+  const dir = path15.join(path15.resolve(opts.root), ".sdd", "changes", slug);
+  if (!SLUG_RE.test(slug)) {
+    return {
+      slug,
+      dir,
+      files: [],
+      diagnostics: [diag("ATLAS-NEW-001", "error", `Slug inv\xE1lido: "${slug}"`, { suggestion: "Usa kebab-case: min\xFAsculas, n\xFAmeros y guiones (2-50 caracteres)" })]
+    };
+  }
+  if (await exists(dir)) {
+    return {
+      slug,
+      dir,
+      files: [],
+      diagnostics: [diag("ATLAS-NEW-002", "error", `El cambio "${slug}" ya existe`, { path: dir })]
+    };
+  }
+  const lane = opts.lane ?? opts.cfg?.lanes.default ?? "standard";
+  const domain = (opts.domain ?? "general").toLowerCase();
+  const title = opts.title ?? slug.replace(/-/g, " ");
+  const meta = {
+    schemaVersion: 1,
+    slug,
+    title,
+    domain,
+    lane,
+    created: (opts.now ?? /* @__PURE__ */ new Date()).toISOString().slice(0, 10)
+  };
+  await ensureDir(dir);
+  const templates = templatesFor(language);
+  const files = [];
+  const metaFile = path15.join(dir, "meta.yaml");
+  await writeText(metaFile, changeMetaYaml(meta));
+  files.push(metaFile);
+  if (lane === "fix") {
+    const fixFile = path15.join(dir, "fix.md");
+    await writeText(fixFile, renderTemplate(templates.fix, { TITLE: title }));
+    files.push(fixFile);
+    return { slug, dir, files, diagnostics };
+  }
+  const proposalFile = path15.join(dir, "proposal.md");
+  await writeText(proposalFile, renderTemplate(templates.proposal, { TITLE: title }));
+  files.push(proposalFile);
+  const domainUpper = domain.replace(/[^a-z0-9]/gi, "").toUpperCase() || "GEN";
+  const deltaFile = path15.join(dir, "spec.md");
+  await writeText(deltaFile, templates.specDelta({ title, domainUpper, domain }));
+  files.push(deltaFile);
+  return { slug, dir, files, diagnostics };
+}
+
+// src/archive.ts
+import { promises as fs } from "fs";
+import path16 from "path";
+var REQ_HEADER_RE = /^###\s+(?:Requisito|Requirement):\s+(REQ-[A-Z0-9-]+)\s*(?:—|-|–)\s*(.*)$/;
+function foldDelta(livingBody, delta, language = "es") {
+  const diagnostics = [];
+  let lines = livingBody.replace(/\r\n?/g, "\n").split("\n");
+  const applied = { added: [], modified: [], removed: [], renamed: [] };
+  const findRange = (id) => {
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+      const m = REQ_HEADER_RE.exec(lines[i] ?? "");
+      if (m && (m[1] ?? "").toUpperCase() === id) {
+        start = i;
+        break;
+      }
+    }
+    if (start < 0) return void 0;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+      if (/^###\s+/.test(lines[i] ?? "")) {
+        end = i;
+        break;
+      }
+    }
+    return { start, end };
+  };
+  for (const req of delta.modified) {
+    const range = findRange(req.id);
+    if (!range) {
+      diagnostics.push(diag("TRACE-007", "error", `No se puede modificar ${req.id}: no existe en la spec viva`, { path: delta.path, line: req.line }));
+      continue;
+    }
+    const rendered = renderRequirement(req, language).split("\n");
+    lines = [...lines.slice(0, range.start), ...rendered, "", ...lines.slice(range.end)];
+    applied.modified.push(req.id);
+  }
+  for (const req of delta.removed) {
+    const range = findRange(req.id);
+    if (!range) {
+      diagnostics.push(diag("TRACE-007", "error", `No se puede eliminar ${req.id}: no existe en la spec viva`, { path: delta.path, line: req.line }));
+      continue;
+    }
+    lines = [...lines.slice(0, range.start), ...lines.slice(range.end)];
+    applied.removed.push(req.id);
+  }
+  for (const rename of delta.renamed) {
+    const range = findRange(rename.from.id);
+    if (!range) {
+      diagnostics.push(diag("TRACE-007", "error", `No se puede renombrar ${rename.from.id}: no existe en la spec viva`, { path: delta.path, line: rename.line }));
+      continue;
+    }
+    const header = lines[range.start] ?? "";
+    const label = /Requirement/i.test(header) ? "Requirement" : "Requisito";
+    lines[range.start] = header.replace(REQ_HEADER_RE, (_match, id) => `### ${label}: ${id} \u2014 ${rename.to.title}`);
+    applied.renamed.push(rename.from.id);
+  }
+  for (const req of delta.added) {
+    const rendered = renderRequirement(req, language);
+    const trimmed = trimTrailingBlanks(lines);
+    lines = [...trimmed, "", ...rendered.split("\n"), ""];
+    applied.added.push(req.id);
+  }
+  return { content: lines.join("\n"), applied, diagnostics };
+}
+function trimTrailingBlanks(lines) {
+  const out = [...lines];
+  while (out.length > 0 && (out[out.length - 1] ?? "").trim() === "") out.pop();
+  return out;
+}
+async function archiveChange(opts) {
+  const root = path16.resolve(opts.root);
+  const diagnostics = [];
+  const { config } = await loadWorkspace(root);
+  const language = opts.language ?? config.project.language;
+  const change = await loadChange(root, opts.slug);
+  diagnostics.push(...change.diagnostics);
+  const emptyFold = { content: "", applied: { added: [], modified: [], removed: [], renamed: [] }, diagnostics: [] };
+  if (!change.meta) {
+    return { slug: opts.slug, fold: emptyFold, diagnostics, dryRun: opts.dryRun ?? false };
+  }
+  if (change.meta.lane === "fix") {
+    if (!change.fix) {
+      diagnostics.push(diag("ATLAS-ARCH-005", "error", `El fix "${opts.slug}" no tiene fix.md`, { path: change.dir }));
+      return { slug: opts.slug, fold: emptyFold, diagnostics, dryRun: opts.dryRun ?? false };
+    }
+    const nowFix = opts.now ?? /* @__PURE__ */ new Date();
+    const targetFix = path16.join(root, ".sdd", "changes", "archive", `${nowFix.toISOString().slice(0, 7)}-${opts.slug}`);
+    if (await exists(targetFix)) {
+      diagnostics.push(diag("ATLAS-ARCH-002", "error", `Ya existe un cambio archivado en ${targetFix}`, { path: targetFix }));
+      return { slug: opts.slug, fold: emptyFold, diagnostics, dryRun: opts.dryRun ?? false };
+    }
+    if (!opts.dryRun) {
+      await ensureDir(path16.dirname(targetFix));
+      await fs.rename(change.dir, targetFix);
+      await regenerateIndex(root, config);
+    }
+    return { slug: opts.slug, archivedTo: targetFix, fold: emptyFold, diagnostics, dryRun: opts.dryRun ?? false };
+  }
+  if (!change.delta) {
+    diagnostics.push(diag("ATLAS-ARCH-003", "error", `El cambio "${opts.slug}" no tiene spec.md (delta): no hay nada que plegar`, { path: change.dir }));
+    return { slug: opts.slug, fold: emptyFold, diagnostics, dryRun: opts.dryRun ?? false };
+  }
+  const domain = change.meta.domain;
+  if (!domain) {
+    diagnostics.push(diag("ATLAS-ARCH-001", "error", `El cambio "${opts.slug}" no declara domain en meta.yaml`, { path: path16.join(change.dir, "meta.yaml") }));
+    return { slug: opts.slug, fold: { content: "", applied: { added: [], modified: [], removed: [], renamed: [] }, diagnostics }, diagnostics, dryRun: opts.dryRun ?? false };
+  }
+  const specFile = path16.join(root, ".sdd", "specs", domain, "spec.md");
+  const existing = await readTextIfExists(specFile);
+  const base = existing ?? `---
+domain: ${domain}
+title: ${change.meta.title ?? domain}
+version: 0
+---
+
+# ${change.meta.title ?? domain}
+`;
+  const fm = parseFrontmatter(base);
+  const fold = foldDelta(fm.body, change.delta, language);
+  diagnostics.push(...fold.diagnostics);
+  const version = typeof fm.data["version"] === "number" ? fm.data["version"] : 0;
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const nextFm = {
+    domain,
+    title: fm.data["title"] ?? change.meta.title ?? domain,
+    owner: fm.data["owner"],
+    version: version + 1,
+    updated: now.toISOString().slice(0, 10)
+  };
+  for (const key of Object.keys(nextFm)) if (nextFm[key] === void 0) delete nextFm[key];
+  const body = fold.content.replace(/^[\r\n]+/, "").trimEnd() + "\n";
+  const nextContent = `---
+${Object.entries(nextFm).map(([k, v]) => `${k}: ${String(v)}`).join("\n")}
+---
+
+${body}`;
+  const month = now.toISOString().slice(0, 7);
+  const archiveDir = path16.join(root, ".sdd", "changes", "archive");
+  const target = path16.join(archiveDir, `${month}-${opts.slug}`);
+  if (await exists(target)) {
+    diagnostics.push(diag("ATLAS-ARCH-002", "error", `Ya existe un cambio archivado en ${target}`, { path: target }));
+    return { slug: opts.slug, domain, fold, diagnostics, dryRun: opts.dryRun ?? false };
+  }
+  if (!opts.dryRun) {
+    await writeText(specFile, nextContent);
+    await ensureDir(archiveDir);
+    await fs.rename(change.dir, target);
+    await regenerateIndex(root, config, now);
+  }
+  return { slug: opts.slug, domain, archivedTo: target, fold, diagnostics, dryRun: opts.dryRun ?? false };
+}
+async function regenerateIndex(root, cfg, now = /* @__PURE__ */ new Date()) {
+  const { workspace, config } = cfg ? { workspace: (await loadWorkspace(root)).workspace, config: cfg } : await loadWorkspace(root);
+  const archiveDir = path16.join(root, ".sdd", "changes", "archive");
+  const archived = await exists(archiveDir) ? (await fs.readdir(archiveDir)).filter((e) => !e.startsWith(".")).length : 0;
+  const markdown = indexMarkdown({
+    projectName: config.project.name,
+    language: config.project.language,
+    specs: workspace.specs.map((s) => ({ domain: s.domain, requirements: s.spec.requirements.length })),
+    changes: workspace.changes.map((c) => ({ slug: c.slug, lane: c.meta?.lane ?? config.lanes.default })),
+    archived
+  });
+  void now;
+  await writeText(path16.join(root, ".sdd", "INDEX.md"), markdown);
+}
+
+// src/doctor.ts
+import path17 from "path";
+async function runDoctor(root) {
+  const findings = [];
+  const { workspace, config } = await loadWorkspace(root);
+  findings.push(...workspace.diagnostics);
+  const approvals = await loadApprovals(workspace.sddDir);
+  findings.push(...approvals.diagnostics);
+  for (const change of workspace.changes) {
+    const deltaPath = path17.join(change.dir, "spec.md");
+    const deltaContent = await readTextIfExists(deltaPath);
+    const approval = verifyApproval(change, approvals.byArtifact, config, deltaContent ?? void 0);
+    if ((change.planPath || change.tasks) && (approval.status === "missing" || approval.status === "stale")) {
+      findings.push(
+        diag("ATLAS-LIFECYCLE-001", "error", `El cambio "${change.slug}" tiene plan/tareas sin una firma vigente de la spec`, {
+          path: deltaPath,
+          suggestion: "Firma la spec (`satlas approve`) o rehaz la aprobaci\xF3n si la spec cambi\xF3"
+        })
+      );
+    }
+    const failing = (change.verify?.evidence ?? []).filter((e) => e.result === "fail");
+    if (failing.length > 0) {
+      findings.push(
+        diag("ATLAS-LIFECYCLE-002", "error", `El cambio "${change.slug}" tiene ${failing.length} evidencia(s) con result: fail`, {
+          path: change.verify?.path,
+          suggestion: "Corrige y vuelve a registrar la evidencia antes de archivar"
+        })
+      );
+    }
+    for (const override of change.meta?.overrides ?? []) {
+      if (!override.reason.trim() || !override.by.trim()) {
+        findings.push(diag("ATLAS-LIFECYCLE-004", "error", `Override del gate "${override.gate}" sin motivo o autor`, { path: path17.join(change.dir, "meta.yaml") }));
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const specRef of workspace.specs) {
+    for (const req of specRef.spec.requirements) {
+      const owner = seen.get(req.id);
+      if (owner && owner !== specRef.domain) {
+        findings.push(diag("ATLAS-TRACE-008", "error", `El requisito ${req.id} est\xE1 duplicado en "${owner}" y "${specRef.domain}"`, { path: specRef.path }));
+      }
+      seen.set(req.id, specRef.domain);
+    }
+  }
+  return { findings, summary: countBySeverity(findings) };
+}
+async function specHashOf(filePath) {
+  const content = await readTextIfExists(filePath);
+  if (content === void 0) return void 0;
+  return artifactHash(content);
+}
+export {
+  BLOCK_HEAD_RE,
+  BUILTIN_PACKS,
+  CONFIG_FILE,
+  CORE_VERSION,
+  REQ_HEAD_RE,
+  REQ_ID_RE,
+  RULE_ID_RE,
+  RULE_RE,
+  RUN_EVENT_TYPES,
+  SCENARIO_HEAD_RE,
+  SCENARIO_ID_RE,
+  SDD_DIR,
+  SLUG_RE,
+  TASK_ID_RE,
+  TASK_LINE_RE,
+  adoptWorkspace,
+  appendRunEvent,
+  approvalsSchema,
+  approveFromGithub,
+  archiveChange,
+  artifactHash,
+  atlasConfigSchema,
+  buildTraceGraph,
+  canonicalizeMarkdown,
+  captureMockups,
+  changeMarker,
+  changeMetaSchema,
+  changeMetaYaml,
+  checkMockups,
+  checkTrace,
+  collectMetrics,
+  commentIssue,
+  compareTaskIds,
+  computeInputsHash,
+  configToYaml,
+  copyFile,
+  countBySeverity,
+  createChange,
+  createIssue,
+  createRun,
+  defaultConfig,
+  defaultTokens,
+  deriveState,
+  detectProfiles,
+  detectRepo,
+  detectionToYaml,
+  diag,
+  editIssue,
+  emitFrontmatter,
+  ensureDir,
+  ensureSddDirs,
+  esc,
+  evaluatePacks,
+  evidenceSummary,
+  exists,
+  findLinkedIssue,
+  findWorkspaceRoot,
+  firstToken,
+  foldDelta,
+  generatePresentation,
+  generateRunId,
+  getNumber,
+  getString,
+  ghAuthStatus,
+  ghAvailable,
+  hasErrors,
+  hasShellMetacharacters,
+  indexMarkdown,
+  initWorkspace,
+  inline,
+  isCommandAllowed,
+  isDirectory,
+  issueBody,
+  issueLabels,
+  laneOrDefault,
+  lintDelta,
+  lintMockupHtml,
+  lintMockupManifest,
+  lintRequirement,
+  lintSpec,
+  lintTasks,
+  lintVerify,
+  listChangeSlugs,
+  listDir,
+  listDirs,
+  listRuns,
+  loadActiveProfile,
+  loadApprovals,
+  loadChange,
+  loadConfig,
+  loadDetectedBest,
+  loadProfileFile,
+  loadProfilesFromDir,
+  loadProjectPacks,
+  loadSpecs,
+  loadWorkspace,
+  matchGlob,
+  mockupManifestSchema,
+  mockupsDir,
+  packFindings,
+  parseApprovals,
+  parseChangeMeta,
+  parseConfig,
+  parseDelta,
+  parseFrontmatter,
+  parseGitHubRemote,
+  parseIssueUrl,
+  parseRequirementBlocks,
+  parseSpecFile,
+  parseTasksFile,
+  parseVerifyFile,
+  patchChangeMeta,
+  planBlock,
+  planMockups,
+  planWaves,
+  profileSchema,
+  readMockupManifest,
+  readRun,
+  readText,
+  readTextIfExists,
+  recordEvidence,
+  regenerateIndex,
+  renderDocument,
+  renderMarkdown,
+  renderRequirement,
+  renderStyles,
+  renderTemplate,
+  resolvePacks,
+  runAnalyze,
+  runDoctor,
+  runProcess,
+  sha256,
+  shortHash,
+  signApproval,
+  specHashOf,
+  splitCommand,
+  stateLabel,
+  syncGithubIssue,
+  templatesFor,
+  toPosix,
+  tokensFile,
+  updateMockupScreenshots,
+  updateRunStatus,
+  verifyApproval,
+  walkFiles,
+  writeConfig,
+  writeMockupManifest,
+  writeMockupPlan,
+  writeText
+};