@hoilab/ada-cli 0.84.21 → 0.85.0

package/dist/core/workflows/builtins.js

@@ -0,0 +1,283 @@
+/**
+ * Builtins — generadores de scripts de workflow (deep-research, code-review,
+ * product-build, codebase-audit, multi-perspective).
+ *
+ * Los builtins son versionados con el SDK y TESTEADOS — no scripts sueltos
+ * del usuario. Devuelven el script que ejecuta el runtime.
+ *
+ * Regla de oro: TODO fragmento estático de prompt se emite con q()
+ * (JSON.stringify) — el escapado queda garantizado por construcción y el
+ * script generado SIEMPRE es JS válido (verificado por tests vm-parse).
+ */
+/** Emite un literal string JS correctamente escapado. */
+function q(s) {
+    return JSON.stringify(s);
+}
+/** Deep-research: plan → gather (parallel, con web tools) → verify → report. */
+export function generateDeepResearchScript(options = {}) {
+    const angles = Math.min(Math.max(options.angles ?? 4, 1), 12);
+    const minSupport = options.minSupport ?? 2;
+    return `export const meta = {
+  "name": "deep_research",
+  "description": "Deep research con búsqueda web y verificación cruzada",
+  "phases": [
+    { "title": "Queries" },
+    { "title": "Gather" },
+    { "title": "Verify" },
+    { "title": "Report" }
+  ]
+}
+
+phase("Queries")
+const plan = await agent({
+  prompt: ${q("Planifica la investigación web para esta pregunta: ")} + (args.question ?? "") +
+    ${q(`\n\nProduce ${angles} consultas diversas y específicas. Devuelve JSON {"queries": ["..."]}.`)},
+  label: "planificar consultas",
+  schema: { type: "object", properties: { queries: { type: "array", items: { type: "string" } } }, required: ["queries"] }
+})
+const planned = plan && Array.isArray(plan.queries) ? plan.queries.filter((q) => typeof q === "string" && q.trim().length > 0) : []
+const queries = (planned.length > 0 ? planned : [args.question ?? ""]).slice(0, ${angles})
+
+phase("Gather")
+const gathered = await parallel(queries.map((q, i) => () =>
+  agent({
+    prompt: ${q("Investiga esta consulta usando las tools web_search y web_fetch.\nConsulta: ")} + q +
+      ${q('\n\nPasos: (1) web_search; (2) web_fetch de las 2 URLs más relevantes; (3) extrae claims verificables, cada uno con su URL exacta. NO inventes fuentes. Devuelve JSON {"sources": [{"url": string, "claims": [string]}]}.')},
+    label: "investigar: " + String(q).slice(0, 60),
+    readOnly: true,
+    web: true,
+    schema: { type: "object", properties: { sources: { type: "array", items: { type: "object", properties: { url: { type: "string" }, claims: { type: "array", items: { type: "string" } } }, required: ["url", "claims"] } } }, required: ["sources"] }
+  })
+))
+const allSources = gathered.filter(Boolean).flatMap((g) => (g && g.sources) || [])
+
+phase("Verify")
+const verified = await agent({
+  prompt: ${q(`Verifica los claims recopilados. Para cada claim, comprueba que tenga al menos ${minSupport} fuentes independientes que lo respalden. Devuelve JSON {"verifiedClaims": [{ "claim": string, "sources": [string] }], "uncertain": [string]}.`)},
+  label: "verificar claims (" + allSources.length + " fuentes)",
+  readOnly: true,
+  schema: { type: "object", properties: { verifiedClaims: { type: "array", items: { type: "object", properties: { claim: { type: "string" }, sources: { type: "array", items: { type: "string" } } }, required: ["claim", "sources"] } }, uncertain: { type: "array", items: { type: "string" } } }, required: ["verifiedClaims", "uncertain"] }
+})
+
+phase("Report")
+const report = await agent({
+  prompt: ${q("Escribe un informe en Markdown sobre: ")} + (args.question ?? "") +
+    ${q('\n\nUsa SOLO los claims verificados, citando las fuentes como [1], [2]... con la lista de fuentes al final. Marca explícitamente lo incierto. Devuelve el informe en JSON {"report": string}.')},
+  label: "redactar informe",
+  schema: { type: "object", properties: { report: { type: "string" } }, required: ["report"] }
+})
+
+return report ? report.report : null
+`;
+}
+/** Code-review: diff por módulo → reviewers paralelos → síntesis con severidad. */
+export function generateCodeReviewScript(options = {}) {
+    const reviewers = Math.min(Math.max(options.reviewers ?? 3, 1), 6);
+    const perspectives = [
+        "bugs y errores lógicos",
+        "seguridad y límites de confianza",
+        "mantenibilidad y deuda técnica",
+    ].slice(0, reviewers);
+    return `export const meta = {
+  "name": "code_review",
+  "description": "Revisión de código con reviewers paralelos y síntesis por severidad",
+  "phases": [
+    { "title": "Diff" },
+    { "title": "Review" },
+    { "title": "Synthesize" }
+  ]
+}
+
+phase("Diff")
+const diff = await agent({
+  prompt: ${q('Obtén el diff del cambio (git diff HEAD~1 o el rango indicado en args.diff). Devuelve JSON {"diff": string} con el diff completo (máx 10000 chars).')},
+  label: "obtener diff",
+  schema: { type: "object", properties: { diff: { type: "string" } }, required: ["diff"] }
+})
+
+phase("Review")
+const perspectives = ${JSON.stringify(perspectives)}
+const reviews = await parallel(perspectives.map((p, i) => () =>
+  agent({
+    prompt: ${q("Revisa el siguiente diff desde la perspectiva: ")} + p +
+      ${q("\n\nDIFF:\n")} + (diff ? diff.diff : "(sin diff)") +
+      ${q('\n\nPara cada hallazgo cita archivo:línea. NO inventes. Devuelve JSON {"findings": [{"severity": "critical|major|minor", "file": string, "line": number, "issue": string, "suggestion": string}]}.')},
+    label: "revisar: " + p,
+    readOnly: true,
+    schema: { type: "object", properties: { findings: { type: "array", items: { type: "object", properties: { severity: { type: "string" }, file: { type: "string" }, line: { type: "number" }, issue: { type: "string" }, suggestion: { type: "string" } }, required: ["severity", "file", "issue"] } } }, required: ["findings"] }
+  })
+))
+
+phase("Synthesize")
+const synthesis = await agent({
+  prompt: ${q('Sintetiza estos hallazgos de revisión en un informe final Markdown ordenado por severidad (crítico primero), sin duplicados y con las citas archivo:línea. Devuelve JSON {"report": string}.')},
+  label: "sintetizar hallazgos",
+  schema: { type: "object", properties: { report: { type: "string" } }, required: ["report"] }
+})
+
+return synthesis ? synthesis.report : null
+`;
+}
+/**
+ * Product-build (Ada Intelligence, §4): acceptance criteria → fases TDD →
+ * verify ejecuta los tests → done con verified_by y evidencia.
+ */
+export function generateProductBuildScript() {
+    return `export const meta = {
+  "name": "product_build",
+  "description": "Construcción de producto con acceptance criteria y verify con evidencia",
+  "phases": [
+    { "title": "Frame" },
+    { "title": "Plan" },
+    { "title": "Build" },
+    { "title": "Verify" },
+    { "title": "Done" }
+  ]
+}
+
+phase("Frame")
+const framed = await agent({
+  prompt: ${q("Enmarca el producto para este brief: ")} + ((args.brief ?? args.acceptanceCriteria) ?? "") +
+    ${q('\n\nDefine acceptance criteria observables y medibles. Devuelve JSON {"criteria": [{"id": string, "description": string}]} (máx 6).')},
+  label: "definir criterios",
+  schema: { type: "object", properties: { criteria: { type: "array", items: { type: "object", properties: { id: { type: "string" }, description: { type: "string" } }, required: ["id", "description"] } } }, required: ["criteria"] }
+})
+const criteria = (framed && framed.criteria) || []
+
+phase("Plan")
+const planned = await agent({
+  prompt: ${q('Planifica las tareas para cumplir estos criterios. Por cada criterio indica el test que lo verifica. Devuelve JSON {"tasks": [{"title": string, "criterion": string, "test": string}]}.\n\nCriterios:\n')} +
+    JSON.stringify(criteria),
+  label: "planificar tareas",
+  schema: { type: "object", properties: { tasks: { type: "array", items: { type: "object", properties: { title: { type: "string" }, criterion: { type: "string" }, test: { type: "string" } }, required: ["title", "criterion"] } } }, required: ["tasks"] }
+})
+
+phase("Build")
+const built = await parallel((planned && planned.tasks || []).map((t, i) => () =>
+  agent({
+    prompt: ${q("Tarea: ")} + t.title + ${q("\nCriterio que resuelve: ")} + t.criterion +
+      ${q("\nImplementa el mínimo y escribe el test: ")} + (t.test ?? "") +
+      ${q('\nEjecuta el test y confirma. Devuelve el archivo que cambiaste en {"file": string, "verified": boolean}.')},
+    label: "construir: " + t.title,
+    isolation: "worktree",
+    schema: { type: "object", properties: { file: { type: "string" }, verified: { type: "boolean" } }, required: ["file", "verified"] }
+  })
+))
+const artifacts = built.filter(Boolean).filter((b) => b && b.verified)
+
+phase("Verify")
+const verification = await agent({
+  prompt: ${q('Ejecuta el/los comando(s) de verificación del proyecto (args.verifyCommand o el test runner default). Para cada criterio, confirma con evidencia archivo:línea o salida de test. Devuelve JSON {"results": [{"criterion": string, "verified_by": string, "evidence": string}]}.')},
+  label: "verificar criterios (" + criteria.length + ")",
+  schema: { type: "object", properties: { results: { type: "array", items: { type: "object", properties: { criterion: { type: "string" }, verified_by: { type: "string" }, evidence: { type: "string" } }, required: ["criterion", "verified_by", "evidence"] } } }, required: ["results"] }
+})
+
+phase("Done")
+const done = await agent({
+  prompt: ${q('Redacta el informe final de build. Solo declara done si CADA criterio tiene verified_by y evidencia. Devuelve JSON {"report": string, "done": boolean, "gaps": [string]}.')},
+  label: "informe final",
+  schema: { type: "object", properties: { report: { type: "string" }, done: { type: "boolean" }, gaps: { type: "array", items: { type: "string" } } }, required: ["report", "done"] }
+})
+
+return done ? done.report || JSON.stringify(done) : null
+`;
+}
+/**
+ * Codebase-audit (§4): módulos → auditoría paralela (seguridad, deuda, bugs,
+ * compliance) → informe + (opcional) nodos QA_FINDING/RISK del grafo.
+ */
+export function generateCodebaseAuditScript(options = {}) {
+    const angles = Math.min(Math.max(options.angles ?? 4, 1), 8);
+    const perspectives = [
+        "seguridad (injection, secrets, límites de confianza)",
+        "deuda técnica y arquitectura",
+        "bugs y correctitud",
+        "cumplimiento / RGPD / datos personales",
+    ].slice(0, angles);
+    const graphHooks = options.graph
+        ? "\n\nTras el informe, usa la tool graph_add_nodes para registrar QA_FINDING y RISK con sus citas."
+        : "";
+    return `export const meta = {
+  "name": "codebase_audit",
+  "description": "Auditoría del codebase con ángulos paralelos y síntesis",
+  "phases": [
+    { "title": "Walk" },
+    { "title": "Audit" },
+    { "title": "Report" }
+  ]
+}
+
+phase("Walk")
+const modules = await agent({
+  prompt: ${q(`Audita este repo: (args.path ?? "."). En qué módulos se dividiría la auditoría. Devuelve JSON {"modules": [string]} (máx ${angles}).`)},
+  label: "identificar módulos",
+  schema: { type: "object", properties: { modules: { type: "array", items: { type: "string" } } }, required: ["modules"] }
+})
+
+phase("Audit")
+const perspectives = ${JSON.stringify(perspectives)}
+const audits = await parallel(perspectives.map((p, i) => () =>
+  agent({
+    prompt: ${q("Audita el módulo(s) desde la perspectiva: ")} + p +
+      ${q("\nMódulos: ")} + JSON.stringify((modules && modules.modules) || []) +
+      ${q(`\nPara cada hallazgo cita archivo:línea. Devuelve JSON {"findings": [{"type": "RISK|QA_FINDING", "severity": string, "file": string, "line": number, "issue": string}]}.${graphHooks}`)},
+    label: "auditar: " + p,
+    schema: { type: "object", properties: { findings: { type: "array", items: { type: "object", properties: { type: { type: "string" }, severity: { type: "string" }, file: { type: "string" }, issue: { type: "string" } }, required: ["type", "severity", "file", "issue"] } } }, required: ["findings"] }
+  })
+))
+
+phase("Report")
+const report = await agent({
+  prompt: ${q('Sintetiza los hallazgos de auditoría en un informe Markdown ordenado por severidad, agrupado por perspectiva, con citas archivo:línea y recomendaciones priorizadas. Devuelve JSON {"report": string}.')},
+  label: "sintetizar auditoría",
+  schema: { type: "object", properties: { report: { type: "string" } }, required: ["report"] }
+})
+
+return report ? report.report : null
+`;
+}
+/**
+ * Multi-perspective (§4): el mismo problema desde N ángulos → síntesis con
+ * desacuerdos explícitos (no consenso falso).
+ */
+export function generateMultiPerspectiveScript(options = {}) {
+    const n = Math.min(Math.max(options.perspectives ?? 4, 2), 8);
+    const list = [
+        "correctitud e invariantes",
+        "rendimiento y escalabilidad",
+        "seguridad y confianza",
+        "mantenibilidad y claridad",
+        "producto y UX",
+        "coste de operación",
+    ].slice(0, n);
+    return `export const meta = {
+  "name": "multi_perspective",
+  "description": "Análisis del mismo problema desde N perspectivas con desacuerdos explícitos",
+  "phases": [
+    { "title": "Perspectives" },
+    { "title": "Synthesize" }
+  ]
+}
+
+phase("Perspectives")
+const views = await parallel(${JSON.stringify(list)}.map((p, i) => () =>
+  agent({
+    prompt: ${q("Analiza este problema: ")} + (args.problem ?? "") +
+      ${q("\nDesde la perspectiva: ")} + p +
+      ${q('\nDa tu análisis, recomendación y riesgos. Devuelve JSON {"perspective": string, "recommendation": string, "risks": [string]}.')},
+    label: "perspectiva: " + p,
+    schema: { type: "object", properties: { perspective: { type: "string" }, recommendation: { type: "string" }, risks: { type: "array", items: { type: "string" } } }, required: ["perspective", "recommendation"] }
+  })
+))
+
+phase("Synthesize")
+const synthesis = await agent({
+  prompt: ${q('Sintetiza los análisis. SEÑALA EXPLÍCITAMENTE los desacuerdos entre perspectivas (no creas consenso falso). Devuelve JSON {"summary": string, "disagreements": [string], "recommended": string}.')},
+  label: "sintetizar análisis",
+  schema: { type: "object", properties: { summary: { type: "string" }, disagreements: { type: "array", items: { type: "string" } }, recommended: { type: "string" } }, required: ["summary", "recommended"] }
+})
+
+return synthesis ? synthesis.summary || JSON.stringify(synthesis) : null
+`;
+}
+//# sourceMappingURL=builtins.js.map

package/dist/core/workflows/builtins.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins.js","sourceRoot":"","sources":["../../../src/core/workflows/builtins.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Builtins — generadores de scripts de workflow (deep-research, code-review,\n * product-build, codebase-audit, multi-perspective).\n *\n * Los builtins son versionados con el SDK y TESTEADOS — no scripts sueltos\n * del usuario. Devuelven el script que ejecuta el runtime.\n *\n * Regla de oro: TODO fragmento estático de prompt se emite con q()\n * (JSON.stringify) — el escapado queda garantizado por construcción y el\n * script generado SIEMPRE es JS válido (verificado por tests vm-parse).\n */\n\n/** Emite un literal string JS correctamente escapado. */\nfunction q(s: string): string {\n\treturn JSON.stringify(s);\n}\n\n/** Deep-research: plan → gather (parallel, con web tools) → verify → report. */\nexport function generateDeepResearchScript(options: { angles?: number; minSupport?: number } = {}): string {\n\tconst angles = Math.min(Math.max(options.angles ?? 4, 1), 12);\n\tconst minSupport = options.minSupport ?? 2;\n\treturn `export const meta = {\n  \"name\": \"deep_research\",\n  \"description\": \"Deep research con búsqueda web y verificación cruzada\",\n  \"phases\": [\n    { \"title\": \"Queries\" },\n    { \"title\": \"Gather\" },\n    { \"title\": \"Verify\" },\n    { \"title\": \"Report\" }\n  ]\n}\n\nphase(\"Queries\")\nconst plan = await agent({\n  prompt: ${q(\"Planifica la investigación web para esta pregunta: \")} + (args.question ?? \"\") +\n    ${q(`\\n\\nProduce ${angles} consultas diversas y específicas. Devuelve JSON {\"queries\": [\"...\"]}.`)},\n  label: \"planificar consultas\",\n  schema: { type: \"object\", properties: { queries: { type: \"array\", items: { type: \"string\" } } }, required: [\"queries\"] }\n})\nconst planned = plan && Array.isArray(plan.queries) ? plan.queries.filter((q) => typeof q === \"string\" && q.trim().length > 0) : []\nconst queries = (planned.length > 0 ? planned : [args.question ?? \"\"]).slice(0, ${angles})\n\nphase(\"Gather\")\nconst gathered = await parallel(queries.map((q, i) => () =>\n  agent({\n    prompt: ${q(\"Investiga esta consulta usando las tools web_search y web_fetch.\\nConsulta: \")} + q +\n      ${q('\\n\\nPasos: (1) web_search; (2) web_fetch de las 2 URLs más relevantes; (3) extrae claims verificables, cada uno con su URL exacta. NO inventes fuentes. Devuelve JSON {\"sources\": [{\"url\": string, \"claims\": [string]}]}.')},\n    label: \"investigar: \" + String(q).slice(0, 60),\n    readOnly: true,\n    web: true,\n    schema: { type: \"object\", properties: { sources: { type: \"array\", items: { type: \"object\", properties: { url: { type: \"string\" }, claims: { type: \"array\", items: { type: \"string\" } } }, required: [\"url\", \"claims\"] } } }, required: [\"sources\"] }\n  })\n))\nconst allSources = gathered.filter(Boolean).flatMap((g) => (g && g.sources) || [])\n\nphase(\"Verify\")\nconst verified = await agent({\n  prompt: ${q(`Verifica los claims recopilados. Para cada claim, comprueba que tenga al menos ${minSupport} fuentes independientes que lo respalden. Devuelve JSON {\"verifiedClaims\": [{ \"claim\": string, \"sources\": [string] }], \"uncertain\": [string]}.`)},\n  label: \"verificar claims (\" + allSources.length + \" fuentes)\",\n  readOnly: true,\n  schema: { type: \"object\", properties: { verifiedClaims: { type: \"array\", items: { type: \"object\", properties: { claim: { type: \"string\" }, sources: { type: \"array\", items: { type: \"string\" } } }, required: [\"claim\", \"sources\"] } }, uncertain: { type: \"array\", items: { type: \"string\" } } }, required: [\"verifiedClaims\", \"uncertain\"] }\n})\n\nphase(\"Report\")\nconst report = await agent({\n  prompt: ${q(\"Escribe un informe en Markdown sobre: \")} + (args.question ?? \"\") +\n    ${q('\\n\\nUsa SOLO los claims verificados, citando las fuentes como [1], [2]... con la lista de fuentes al final. Marca explícitamente lo incierto. Devuelve el informe en JSON {\"report\": string}.')},\n  label: \"redactar informe\",\n  schema: { type: \"object\", properties: { report: { type: \"string\" } }, required: [\"report\"] }\n})\n\nreturn report ? report.report : null\n`;\n}\n\n/** Code-review: diff por módulo → reviewers paralelos → síntesis con severidad. */\nexport function generateCodeReviewScript(options: { reviewers?: number } = {}): string {\n\tconst reviewers = Math.min(Math.max(options.reviewers ?? 3, 1), 6);\n\tconst perspectives = [\n\t\t\"bugs y errores lógicos\",\n\t\t\"seguridad y límites de confianza\",\n\t\t\"mantenibilidad y deuda técnica\",\n\t].slice(0, reviewers);\n\treturn `export const meta = {\n  \"name\": \"code_review\",\n  \"description\": \"Revisión de código con reviewers paralelos y síntesis por severidad\",\n  \"phases\": [\n    { \"title\": \"Diff\" },\n    { \"title\": \"Review\" },\n    { \"title\": \"Synthesize\" }\n  ]\n}\n\nphase(\"Diff\")\nconst diff = await agent({\n  prompt: ${q('Obtén el diff del cambio (git diff HEAD~1 o el rango indicado en args.diff). Devuelve JSON {\"diff\": string} con el diff completo (máx 10000 chars).')},\n  label: \"obtener diff\",\n  schema: { type: \"object\", properties: { diff: { type: \"string\" } }, required: [\"diff\"] }\n})\n\nphase(\"Review\")\nconst perspectives = ${JSON.stringify(perspectives)}\nconst reviews = await parallel(perspectives.map((p, i) => () =>\n  agent({\n    prompt: ${q(\"Revisa el siguiente diff desde la perspectiva: \")} + p +\n      ${q(\"\\n\\nDIFF:\\n\")} + (diff ? diff.diff : \"(sin diff)\") +\n      ${q('\\n\\nPara cada hallazgo cita archivo:línea. NO inventes. Devuelve JSON {\"findings\": [{\"severity\": \"critical|major|minor\", \"file\": string, \"line\": number, \"issue\": string, \"suggestion\": string}]}.')},\n    label: \"revisar: \" + p,\n    readOnly: true,\n    schema: { type: \"object\", properties: { findings: { type: \"array\", items: { type: \"object\", properties: { severity: { type: \"string\" }, file: { type: \"string\" }, line: { type: \"number\" }, issue: { type: \"string\" }, suggestion: { type: \"string\" } }, required: [\"severity\", \"file\", \"issue\"] } } }, required: [\"findings\"] }\n  })\n))\n\nphase(\"Synthesize\")\nconst synthesis = await agent({\n  prompt: ${q('Sintetiza estos hallazgos de revisión en un informe final Markdown ordenado por severidad (crítico primero), sin duplicados y con las citas archivo:línea. Devuelve JSON {\"report\": string}.')},\n  label: \"sintetizar hallazgos\",\n  schema: { type: \"object\", properties: { report: { type: \"string\" } }, required: [\"report\"] }\n})\n\nreturn synthesis ? synthesis.report : null\n`;\n}\n\n/**\n * Product-build (Ada Intelligence, §4): acceptance criteria → fases TDD →\n * verify ejecuta los tests → done con verified_by y evidencia.\n */\nexport function generateProductBuildScript(): string {\n\treturn `export const meta = {\n  \"name\": \"product_build\",\n  \"description\": \"Construcción de producto con acceptance criteria y verify con evidencia\",\n  \"phases\": [\n    { \"title\": \"Frame\" },\n    { \"title\": \"Plan\" },\n    { \"title\": \"Build\" },\n    { \"title\": \"Verify\" },\n    { \"title\": \"Done\" }\n  ]\n}\n\nphase(\"Frame\")\nconst framed = await agent({\n  prompt: ${q(\"Enmarca el producto para este brief: \")} + ((args.brief ?? args.acceptanceCriteria) ?? \"\") +\n    ${q('\\n\\nDefine acceptance criteria observables y medibles. Devuelve JSON {\"criteria\": [{\"id\": string, \"description\": string}]} (máx 6).')},\n  label: \"definir criterios\",\n  schema: { type: \"object\", properties: { criteria: { type: \"array\", items: { type: \"object\", properties: { id: { type: \"string\" }, description: { type: \"string\" } }, required: [\"id\", \"description\"] } } }, required: [\"criteria\"] }\n})\nconst criteria = (framed && framed.criteria) || []\n\nphase(\"Plan\")\nconst planned = await agent({\n  prompt: ${q('Planifica las tareas para cumplir estos criterios. Por cada criterio indica el test que lo verifica. Devuelve JSON {\"tasks\": [{\"title\": string, \"criterion\": string, \"test\": string}]}.\\n\\nCriterios:\\n')} +\n    JSON.stringify(criteria),\n  label: \"planificar tareas\",\n  schema: { type: \"object\", properties: { tasks: { type: \"array\", items: { type: \"object\", properties: { title: { type: \"string\" }, criterion: { type: \"string\" }, test: { type: \"string\" } }, required: [\"title\", \"criterion\"] } } }, required: [\"tasks\"] }\n})\n\nphase(\"Build\")\nconst built = await parallel((planned && planned.tasks || []).map((t, i) => () =>\n  agent({\n    prompt: ${q(\"Tarea: \")} + t.title + ${q(\"\\nCriterio que resuelve: \")} + t.criterion +\n      ${q(\"\\nImplementa el mínimo y escribe el test: \")} + (t.test ?? \"\") +\n      ${q('\\nEjecuta el test y confirma. Devuelve el archivo que cambiaste en {\"file\": string, \"verified\": boolean}.')},\n    label: \"construir: \" + t.title,\n    isolation: \"worktree\",\n    schema: { type: \"object\", properties: { file: { type: \"string\" }, verified: { type: \"boolean\" } }, required: [\"file\", \"verified\"] }\n  })\n))\nconst artifacts = built.filter(Boolean).filter((b) => b && b.verified)\n\nphase(\"Verify\")\nconst verification = await agent({\n  prompt: ${q('Ejecuta el/los comando(s) de verificación del proyecto (args.verifyCommand o el test runner default). Para cada criterio, confirma con evidencia archivo:línea o salida de test. Devuelve JSON {\"results\": [{\"criterion\": string, \"verified_by\": string, \"evidence\": string}]}.')},\n  label: \"verificar criterios (\" + criteria.length + \")\",\n  schema: { type: \"object\", properties: { results: { type: \"array\", items: { type: \"object\", properties: { criterion: { type: \"string\" }, verified_by: { type: \"string\" }, evidence: { type: \"string\" } }, required: [\"criterion\", \"verified_by\", \"evidence\"] } } }, required: [\"results\"] }\n})\n\nphase(\"Done\")\nconst done = await agent({\n  prompt: ${q('Redacta el informe final de build. Solo declara done si CADA criterio tiene verified_by y evidencia. Devuelve JSON {\"report\": string, \"done\": boolean, \"gaps\": [string]}.')},\n  label: \"informe final\",\n  schema: { type: \"object\", properties: { report: { type: \"string\" }, done: { type: \"boolean\" }, gaps: { type: \"array\", items: { type: \"string\" } } }, required: [\"report\", \"done\"] }\n})\n\nreturn done ? done.report || JSON.stringify(done) : null\n`;\n}\n\n/**\n * Codebase-audit (§4): módulos → auditoría paralela (seguridad, deuda, bugs,\n * compliance) → informe + (opcional) nodos QA_FINDING/RISK del grafo.\n */\nexport function generateCodebaseAuditScript(options: { angles?: number; graph?: boolean } = {}): string {\n\tconst angles = Math.min(Math.max(options.angles ?? 4, 1), 8);\n\tconst perspectives = [\n\t\t\"seguridad (injection, secrets, límites de confianza)\",\n\t\t\"deuda técnica y arquitectura\",\n\t\t\"bugs y correctitud\",\n\t\t\"cumplimiento / RGPD / datos personales\",\n\t].slice(0, angles);\n\tconst graphHooks = options.graph\n\t\t? \"\\n\\nTras el informe, usa la tool graph_add_nodes para registrar QA_FINDING y RISK con sus citas.\"\n\t\t: \"\";\n\treturn `export const meta = {\n  \"name\": \"codebase_audit\",\n  \"description\": \"Auditoría del codebase con ángulos paralelos y síntesis\",\n  \"phases\": [\n    { \"title\": \"Walk\" },\n    { \"title\": \"Audit\" },\n    { \"title\": \"Report\" }\n  ]\n}\n\nphase(\"Walk\")\nconst modules = await agent({\n  prompt: ${q(`Audita este repo: (args.path ?? \".\"). En qué módulos se dividiría la auditoría. Devuelve JSON {\"modules\": [string]} (máx ${angles}).`)},\n  label: \"identificar módulos\",\n  schema: { type: \"object\", properties: { modules: { type: \"array\", items: { type: \"string\" } } }, required: [\"modules\"] }\n})\n\nphase(\"Audit\")\nconst perspectives = ${JSON.stringify(perspectives)}\nconst audits = await parallel(perspectives.map((p, i) => () =>\n  agent({\n    prompt: ${q(\"Audita el módulo(s) desde la perspectiva: \")} + p +\n      ${q(\"\\nMódulos: \")} + JSON.stringify((modules && modules.modules) || []) +\n      ${q(`\\nPara cada hallazgo cita archivo:línea. Devuelve JSON {\"findings\": [{\"type\": \"RISK|QA_FINDING\", \"severity\": string, \"file\": string, \"line\": number, \"issue\": string}]}.${graphHooks}`)},\n    label: \"auditar: \" + p,\n    schema: { type: \"object\", properties: { findings: { type: \"array\", items: { type: \"object\", properties: { type: { type: \"string\" }, severity: { type: \"string\" }, file: { type: \"string\" }, issue: { type: \"string\" } }, required: [\"type\", \"severity\", \"file\", \"issue\"] } } }, required: [\"findings\"] }\n  })\n))\n\nphase(\"Report\")\nconst report = await agent({\n  prompt: ${q('Sintetiza los hallazgos de auditoría en un informe Markdown ordenado por severidad, agrupado por perspectiva, con citas archivo:línea y recomendaciones priorizadas. Devuelve JSON {\"report\": string}.')},\n  label: \"sintetizar auditoría\",\n  schema: { type: \"object\", properties: { report: { type: \"string\" } }, required: [\"report\"] }\n})\n\nreturn report ? report.report : null\n`;\n}\n\n/**\n * Multi-perspective (§4): el mismo problema desde N ángulos → síntesis con\n * desacuerdos explícitos (no consenso falso).\n */\nexport function generateMultiPerspectiveScript(options: { perspectives?: number } = {}): string {\n\tconst n = Math.min(Math.max(options.perspectives ?? 4, 2), 8);\n\tconst list = [\n\t\t\"correctitud e invariantes\",\n\t\t\"rendimiento y escalabilidad\",\n\t\t\"seguridad y confianza\",\n\t\t\"mantenibilidad y claridad\",\n\t\t\"producto y UX\",\n\t\t\"coste de operación\",\n\t].slice(0, n);\n\treturn `export const meta = {\n  \"name\": \"multi_perspective\",\n  \"description\": \"Análisis del mismo problema desde N perspectivas con desacuerdos explícitos\",\n  \"phases\": [\n    { \"title\": \"Perspectives\" },\n    { \"title\": \"Synthesize\" }\n  ]\n}\n\nphase(\"Perspectives\")\nconst views = await parallel(${JSON.stringify(list)}.map((p, i) => () =>\n  agent({\n    prompt: ${q(\"Analiza este problema: \")} + (args.problem ?? \"\") +\n      ${q(\"\\nDesde la perspectiva: \")} + p +\n      ${q('\\nDa tu análisis, recomendación y riesgos. Devuelve JSON {\"perspective\": string, \"recommendation\": string, \"risks\": [string]}.')},\n    label: \"perspectiva: \" + p,\n    schema: { type: \"object\", properties: { perspective: { type: \"string\" }, recommendation: { type: \"string\" }, risks: { type: \"array\", items: { type: \"string\" } } }, required: [\"perspective\", \"recommendation\"] }\n  })\n))\n\nphase(\"Synthesize\")\nconst synthesis = await agent({\n  prompt: ${q('Sintetiza los análisis. SEÑALA EXPLÍCITAMENTE los desacuerdos entre perspectivas (no creas consenso falso). Devuelve JSON {\"summary\": string, \"disagreements\": [string], \"recommended\": string}.')},\n  label: \"sintetizar análisis\",\n  schema: { type: \"object\", properties: { summary: { type: \"string\" }, disagreements: { type: \"array\", items: { type: \"string\" } }, recommended: { type: \"string\" } }, required: [\"summary\", \"recommended\"] }\n})\n\nreturn synthesis ? synthesis.summary || JSON.stringify(synthesis) : null\n`;\n}\n"]}

package/dist/core/workflows/contrato/esquema.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Esquema de salida de un subagente.
+ *
+ * Se declara en el frontmatter de su definición (`~/.ada/agents/<n>.md`,
+ * campo `outputSchema`) o se pasa por el script del workflow
+ * (`agent({ schema })`). El host valida la salida contra él — ver
+ * `validador.ts` para el reintento cuando no valida.
+ *
+ * typebox 1.x serializa `Type.Object(...)` como JSON Schema plano (sin
+ * símbolos ni funciones), así que un `outputSchema:` escrito a mano en YAML
+ * es intercambiable con un `Type.Object(...)` del script sin ningún paso de
+ * conversión — YAML anidado y JSON Schema son la misma forma.
+ */
+import type { TSchema } from "typebox";
+export interface ResultadoComprobacion {
+    valida: boolean;
+    /** Un mensaje por error, con su ruta dentro del valor. Vacío si `valida`. */
+    errores: string[];
+}
+/**
+ * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para
+ * validar nada.
+ *
+ * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER
+ * valor sin restricción — eso no es "sin esquema" (que el caller distingue
+ * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y
+ * dejarlo pasar haría que todo "validara" en silencio.
+ */
+export declare function esEsquemaValido(valor: unknown): valor is TSchema;
+/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */
+export declare function comprobar(esquema: TSchema, valor: unknown): ResultadoComprobacion;
+//# sourceMappingURL=esquema.d.ts.map

package/dist/core/workflows/contrato/esquema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esquema.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/esquema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAGvC,MAAM,WAAW,qBAAqB;IACrC,MAAM,EAAE,OAAO,CAAC;IAChB,8EAA6E;IAC7E,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAID;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,CAIhE;AAED,4EAA4E;AAC5E,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,qBAAqB,CAIjF","sourcesContent":["/**\n * Esquema de salida de un subagente.\n *\n * Se declara en el frontmatter de su definición (`~/.ada/agents/<n>.md`,\n * campo `outputSchema`) o se pasa por el script del workflow\n * (`agent({ schema })`). El host valida la salida contra él — ver\n * `validador.ts` para el reintento cuando no valida.\n *\n * typebox 1.x serializa `Type.Object(...)` como JSON Schema plano (sin\n * símbolos ni funciones), así que un `outputSchema:` escrito a mano en YAML\n * es intercambiable con un `Type.Object(...)` del script sin ningún paso de\n * conversión — YAML anidado y JSON Schema son la misma forma.\n */\nimport type { TSchema } from \"typebox\";\nimport { Value } from \"typebox/value\";\n\nexport interface ResultadoComprobacion {\n\tvalida: boolean;\n\t/** Un mensaje por error, con su ruta dentro del valor. Vacío si `valida`. */\n\terrores: string[];\n}\n\nconst CLAVES_DE_FORMA = [\"type\", \"properties\", \"anyOf\", \"oneOf\", \"allOf\", \"$ref\", \"enum\", \"const\"] as const;\n\n/**\n * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para\n * validar nada.\n *\n * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER\n * valor sin restricción — eso no es \"sin esquema\" (que el caller distingue\n * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y\n * dejarlo pasar haría que todo \"validara\" en silencio.\n */\nexport function esEsquemaValido(valor: unknown): valor is TSchema {\n\tif (valor === null || typeof valor !== \"object\" || Array.isArray(valor)) return false;\n\tconst claves = Object.keys(valor as Record<string, unknown>);\n\treturn claves.some((c) => (CLAVES_DE_FORMA as readonly string[]).includes(c));\n}\n\n/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */\nexport function comprobar(esquema: TSchema, valor: unknown): ResultadoComprobacion {\n\tif (Value.Check(esquema, valor)) return { valida: true, errores: [] };\n\tconst errores = [...Value.Errors(esquema, valor)].map((e) => `${e.instancePath || \"(raíz)\"}: ${e.message}`);\n\treturn { valida: false, errores };\n}\n"]}

package/dist/core/workflows/contrato/esquema.js

@@ -0,0 +1,25 @@
+import { Value } from "typebox/value";
+const CLAVES_DE_FORMA = ["type", "properties", "anyOf", "oneOf", "allOf", "$ref", "enum", "const"];
+/**
+ * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para
+ * validar nada.
+ *
+ * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER
+ * valor sin restricción — eso no es "sin esquema" (que el caller distingue
+ * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y
+ * dejarlo pasar haría que todo "validara" en silencio.
+ */
+export function esEsquemaValido(valor) {
+    if (valor === null || typeof valor !== "object" || Array.isArray(valor))
+        return false;
+    const claves = Object.keys(valor);
+    return claves.some((c) => CLAVES_DE_FORMA.includes(c));
+}
+/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */
+export function comprobar(esquema, valor) {
+    if (Value.Check(esquema, valor))
+        return { valida: true, errores: [] };
+    const errores = [...Value.Errors(esquema, valor)].map((e) => `${e.instancePath || "(raíz)"}: ${e.message}`);
+    return { valida: false, errores };
+}
+//# sourceMappingURL=esquema.js.map

package/dist/core/workflows/contrato/esquema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"esquema.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/esquema.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAQtC,MAAM,eAAe,GAAG,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAU,CAAC;AAE5G;;;;;;;;GAQG;AACH,MAAM,UAAU,eAAe,CAAC,KAAc,EAAoB;IACjE,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IACtF,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAgC,CAAC,CAAC;IAC7D,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,eAAqC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;AAAA,CAC9E;AAED,4EAA4E;AAC5E,MAAM,UAAU,SAAS,CAAC,OAAgB,EAAE,KAAc,EAAyB;IAClF,IAAI,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;IACtE,MAAM,OAAO,GAAG,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,YAAY,IAAI,SAAQ,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC;IAC5G,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;AAAA,CAClC","sourcesContent":["/**\n * Esquema de salida de un subagente.\n *\n * Se declara en el frontmatter de su definición (`~/.ada/agents/<n>.md`,\n * campo `outputSchema`) o se pasa por el script del workflow\n * (`agent({ schema })`). El host valida la salida contra él — ver\n * `validador.ts` para el reintento cuando no valida.\n *\n * typebox 1.x serializa `Type.Object(...)` como JSON Schema plano (sin\n * símbolos ni funciones), así que un `outputSchema:` escrito a mano en YAML\n * es intercambiable con un `Type.Object(...)` del script sin ningún paso de\n * conversión — YAML anidado y JSON Schema son la misma forma.\n */\nimport type { TSchema } from \"typebox\";\nimport { Value } from \"typebox/value\";\n\nexport interface ResultadoComprobacion {\n\tvalida: boolean;\n\t/** Un mensaje por error, con su ruta dentro del valor. Vacío si `valida`. */\n\terrores: string[];\n}\n\nconst CLAVES_DE_FORMA = [\"type\", \"properties\", \"anyOf\", \"oneOf\", \"allOf\", \"$ref\", \"enum\", \"const\"] as const;\n\n/**\n * Comprueba que `valor` TIENE PINTA de JSON Schema antes de usarlo para\n * validar nada.\n *\n * Un esquema vacío (`{}`) o sin ninguna de estas claves acepta CUALQUIER\n * valor sin restricción — eso no es \"sin esquema\" (que el caller distingue\n * con `undefined`/ausencia del campo), es un esquema declarado pero roto, y\n * dejarlo pasar haría que todo \"validara\" en silencio.\n */\nexport function esEsquemaValido(valor: unknown): valor is TSchema {\n\tif (valor === null || typeof valor !== \"object\" || Array.isArray(valor)) return false;\n\tconst claves = Object.keys(valor as Record<string, unknown>);\n\treturn claves.some((c) => (CLAVES_DE_FORMA as readonly string[]).includes(c));\n}\n\n/** Comprueba `valor` contra `esquema`. Errores concretos: ruta + motivo. */\nexport function comprobar(esquema: TSchema, valor: unknown): ResultadoComprobacion {\n\tif (Value.Check(esquema, valor)) return { valida: true, errores: [] };\n\tconst errores = [...Value.Errors(esquema, valor)].map((e) => `${e.instancePath || \"(raíz)\"}: ${e.message}`);\n\treturn { valida: false, errores };\n}\n"]}

package/dist/core/workflows/contrato/reparar-argumentos.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Reparación de argumentos de tool mal formados, ANTES de gastar un turno en
+ * un error de validación.
+ *
+ * Dos capas, deliberadamente separadas porque arreglan cosas distintas:
+ *
+ * 1. `repararJSON` — un campo de texto que debería ser un objeto/array llega
+ *    con una coma colgante o doblemente serializado (fallos típicos de LLM).
+ *    Parseo tolerante con UN solo intento de arreglo; nunca reescribe
+ *    comillas simples ni añade comillas a claves sueltas — eso puede corromper
+ *    contenido legítimo (código, texto con comillas), y aquí perder el atajo
+ *    es barato, pero corromper datos no lo es.
+ *
+ * 2. `repararConEsquema` — campo de más (`additionalProperties: false`) y
+ *    número/booleano-como-cadena, en las propiedades del NIVEL SUPERIOR del
+ *    objeto. Lee `type`/`properties`/`additionalProperties` directamente del
+ *    esquema en vez de delegar en `Value.Clean`/`Value.Convert` de
+ *    `typebox/value`: esas dos SOLO reconocen esquemas construidos con
+ *    `Type.Object(...)` (llevan una marca interna de "tipo de nodo" que
+ *    `JSON.stringify` no serializa); un esquema declarado a mano en YAML
+ *    (`outputSchema:` del frontmatter de un agente, parseado a un objeto
+ *    plano) NO la lleva, y Clean/Convert se quedan calladas sin tocar nada —
+ *    un "no pude" disfrazado de éxito, descubierto ejecutándolo de verdad, no
+ *    leyendo la documentación. Leer la forma JSON a pelo funciona igual para
+ *    los dos orígenes, porque ambos SON JSON Schema plano una vez
+ *    serializados.
+ *
+ *    Nunca inventa un valor para un campo que no se puede convertir de
+ *    verdad (una cadena "abc" en un campo number se queda "abc", no se
+ *    convierte en `0`) — un valor inventado en silencio es peor que el error
+ *    que reemplaza, exactamente el defecto que la regla del proyecto prohíbe
+ *    (que "no pude" se lea como éxito).
+ */
+import type { TSchema } from "typebox";
+export interface JSONReparado {
+    valor: unknown;
+    /** true si hizo falta el arreglo de coma colgante (el parseo directo falló). */
+    reparado: boolean;
+}
+/**
+ * Parseo tolerante de JSON: intento directo y, si falla, un único intento
+ * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —
+ * "no pude repararlo", no "el valor es nulo".
+ */
+export declare function repararJSON(texto: string): JSONReparado | undefined;
+export interface ValorReparado {
+    valor: unknown;
+    /** true si se quitó algún campo de más o se convirtió algún tipo. */
+    reparado: boolean;
+}
+/**
+ * Repara `valor` contra `esquema`: quita campos de más del nivel superior
+ * cuando el esquema es cerrado (`additionalProperties: false`) y convierte
+ * número-como-cadena / booleano-como-cadena en las propiedades declaradas,
+ * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de
+ * argumentos de una tool, que es plano por construcción.
+ */
+export declare function repararConEsquema(esquema: TSchema, valor: unknown): ValorReparado;
+/**
+ * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`
+ * a los campos de texto indicados (los que un modelo puede mandar doblemente
+ * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye
+ * un campo de texto cuando el JSON reparado es un objeto o array — un valor
+ * de texto que por casualidad parsea como número o booleano ("42", "true") se
+ * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso
+ * decir, no un valor doblemente serializado.
+ */
+export declare function repararArgumentos<T = unknown>(esquema: TSchema, camposTexto?: string[]): (args: unknown) => T;
+//# sourceMappingURL=reparar-argumentos.d.ts.map

package/dist/core/workflows/contrato/reparar-argumentos.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparar-argumentos.d.ts","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/reparar-argumentos.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAOvC,MAAM,WAAW,YAAY;IAC5B,KAAK,EAAE,OAAO,CAAC;IACf,iFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAanE;AAED,MAAM,WAAW,aAAa;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,0EAAqE;IACrE,QAAQ,EAAE,OAAO,CAAC;CAClB;AAoBD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,aAAa,CAuCjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,GAAE,MAAM,EAAO,GAAG,CAAC,IAAI,EAAE,OAAO,KAAK,CAAC,CAiBjH","sourcesContent":["/**\n * Reparación de argumentos de tool mal formados, ANTES de gastar un turno en\n * un error de validación.\n *\n * Dos capas, deliberadamente separadas porque arreglan cosas distintas:\n *\n * 1. `repararJSON` — un campo de texto que debería ser un objeto/array llega\n *    con una coma colgante o doblemente serializado (fallos típicos de LLM).\n *    Parseo tolerante con UN solo intento de arreglo; nunca reescribe\n *    comillas simples ni añade comillas a claves sueltas — eso puede corromper\n *    contenido legítimo (código, texto con comillas), y aquí perder el atajo\n *    es barato, pero corromper datos no lo es.\n *\n * 2. `repararConEsquema` — campo de más (`additionalProperties: false`) y\n *    número/booleano-como-cadena, en las propiedades del NIVEL SUPERIOR del\n *    objeto. Lee `type`/`properties`/`additionalProperties` directamente del\n *    esquema en vez de delegar en `Value.Clean`/`Value.Convert` de\n *    `typebox/value`: esas dos SOLO reconocen esquemas construidos con\n *    `Type.Object(...)` (llevan una marca interna de \"tipo de nodo\" que\n *    `JSON.stringify` no serializa); un esquema declarado a mano en YAML\n *    (`outputSchema:` del frontmatter de un agente, parseado a un objeto\n *    plano) NO la lleva, y Clean/Convert se quedan calladas sin tocar nada —\n *    un \"no pude\" disfrazado de éxito, descubierto ejecutándolo de verdad, no\n *    leyendo la documentación. Leer la forma JSON a pelo funciona igual para\n *    los dos orígenes, porque ambos SON JSON Schema plano una vez\n *    serializados.\n *\n *    Nunca inventa un valor para un campo que no se puede convertir de\n *    verdad (una cadena \"abc\" en un campo number se queda \"abc\", no se\n *    convierte en `0`) — un valor inventado en silencio es peor que el error\n *    que reemplaza, exactamente el defecto que la regla del proyecto prohíbe\n *    (que \"no pude\" se lea como éxito).\n */\nimport type { TSchema } from \"typebox\";\n\n/** Quita una coma colgante antes de `}`/`]` — el error de JSON más común de un LLM. */\nfunction quitarComaColgante(texto: string): string {\n\treturn texto.replace(/,(\\s*[}\\]])/g, \"$1\");\n}\n\nexport interface JSONReparado {\n\tvalor: unknown;\n\t/** true si hizo falta el arreglo de coma colgante (el parseo directo falló). */\n\treparado: boolean;\n}\n\n/**\n * Parseo tolerante de JSON: intento directo y, si falla, un único intento\n * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —\n * \"no pude repararlo\", no \"el valor es nulo\".\n */\nexport function repararJSON(texto: string): JSONReparado | undefined {\n\ttry {\n\t\treturn { valor: JSON.parse(texto), reparado: false };\n\t} catch {\n\t\t// sigue con el intento de arreglo\n\t}\n\tconst sinComa = quitarComaColgante(texto);\n\tif (sinComa === texto) return undefined;\n\ttry {\n\t\treturn { valor: JSON.parse(sinComa), reparado: true };\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\nexport interface ValorReparado {\n\tvalor: unknown;\n\t/** true si se quitó algún campo de más o se convirtió algún tipo. */\n\treparado: boolean;\n}\n\ninterface FormaObjeto {\n\ttype?: unknown;\n\tproperties?: Record<string, { type?: unknown }>;\n\tadditionalProperties?: unknown;\n}\n\nfunction comoNumero(texto: string): number | undefined {\n\tif (texto.trim() === \"\") return undefined;\n\tconst n = Number(texto);\n\treturn Number.isFinite(n) ? n : undefined;\n}\n\nfunction comoBooleano(texto: string): boolean | undefined {\n\tif (texto === \"true\") return true;\n\tif (texto === \"false\") return false;\n\treturn undefined;\n}\n\n/**\n * Repara `valor` contra `esquema`: quita campos de más del nivel superior\n * cuando el esquema es cerrado (`additionalProperties: false`) y convierte\n * número-como-cadena / booleano-como-cadena en las propiedades declaradas,\n * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de\n * argumentos de una tool, que es plano por construcción.\n */\nexport function repararConEsquema(esquema: TSchema, valor: unknown): ValorReparado {\n\tif (valor === null || typeof valor !== \"object\" || Array.isArray(valor)) return { valor, reparado: false };\n\tconst forma = esquema as FormaObjeto;\n\tif (forma.type !== \"object\" || forma.properties === null || typeof forma.properties !== \"object\") {\n\t\treturn { valor, reparado: false };\n\t}\n\tconst propiedades = forma.properties;\n\tconst cerrado = forma.additionalProperties === false;\n\tlet reparado = false;\n\tconst salida: Record<string, unknown> = {};\n\tfor (const [clave, actual] of Object.entries(valor as Record<string, unknown>)) {\n\t\tconst propEsquema = propiedades[clave];\n\t\tif (!propEsquema) {\n\t\t\tif (cerrado) {\n\t\t\t\treparado = true; // campo de más: se quita\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tsalida[clave] = actual;\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof actual === \"string\" && propEsquema.type === \"number\") {\n\t\t\tconst convertido = comoNumero(actual);\n\t\t\tif (convertido !== undefined) {\n\t\t\t\tsalida[clave] = convertido;\n\t\t\t\treparado = true;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tif (typeof actual === \"string\" && propEsquema.type === \"boolean\") {\n\t\t\tconst convertido = comoBooleano(actual);\n\t\t\tif (convertido !== undefined) {\n\t\t\t\tsalida[clave] = convertido;\n\t\t\t\treparado = true;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tsalida[clave] = actual;\n\t}\n\treturn { valor: salida, reparado };\n}\n\n/**\n * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`\n * a los campos de texto indicados (los que un modelo puede mandar doblemente\n * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye\n * un campo de texto cuando el JSON reparado es un objeto o array — un valor\n * de texto que por casualidad parsea como número o booleano (\"42\", \"true\") se\n * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso\n * decir, no un valor doblemente serializado.\n */\nexport function repararArgumentos<T = unknown>(esquema: TSchema, camposTexto: string[] = []): (args: unknown) => T {\n\treturn (args: unknown): T => {\n\t\tif (args === null || typeof args !== \"object\") return args as T;\n\t\tlet objeto = args as Record<string, unknown>;\n\t\tlet huboReparoDeTexto = false;\n\t\tfor (const campo of camposTexto) {\n\t\t\tconst bruto = objeto[campo];\n\t\t\tif (typeof bruto !== \"string\") continue;\n\t\t\tconst parseado = repararJSON(bruto);\n\t\t\tif (parseado && parseado.valor !== null && typeof parseado.valor === \"object\") {\n\t\t\t\tobjeto = { ...objeto, [campo]: parseado.valor };\n\t\t\t\thuboReparoDeTexto = true;\n\t\t\t}\n\t\t}\n\t\tconst { valor, reparado } = repararConEsquema(esquema, objeto);\n\t\treturn (huboReparoDeTexto || reparado ? valor : args) as T;\n\t};\n}\n"]}

package/dist/core/workflows/contrato/reparar-argumentos.js

@@ -0,0 +1,117 @@
+/** Quita una coma colgante antes de `}`/`]` — el error de JSON más común de un LLM. */
+function quitarComaColgante(texto) {
+    return texto.replace(/,(\s*[}\]])/g, "$1");
+}
+/**
+ * Parseo tolerante de JSON: intento directo y, si falla, un único intento
+ * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —
+ * "no pude repararlo", no "el valor es nulo".
+ */
+export function repararJSON(texto) {
+    try {
+        return { valor: JSON.parse(texto), reparado: false };
+    }
+    catch {
+        // sigue con el intento de arreglo
+    }
+    const sinComa = quitarComaColgante(texto);
+    if (sinComa === texto)
+        return undefined;
+    try {
+        return { valor: JSON.parse(sinComa), reparado: true };
+    }
+    catch {
+        return undefined;
+    }
+}
+function comoNumero(texto) {
+    if (texto.trim() === "")
+        return undefined;
+    const n = Number(texto);
+    return Number.isFinite(n) ? n : undefined;
+}
+function comoBooleano(texto) {
+    if (texto === "true")
+        return true;
+    if (texto === "false")
+        return false;
+    return undefined;
+}
+/**
+ * Repara `valor` contra `esquema`: quita campos de más del nivel superior
+ * cuando el esquema es cerrado (`additionalProperties: false`) y convierte
+ * número-como-cadena / booleano-como-cadena en las propiedades declaradas,
+ * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de
+ * argumentos de una tool, que es plano por construcción.
+ */
+export function repararConEsquema(esquema, valor) {
+    if (valor === null || typeof valor !== "object" || Array.isArray(valor))
+        return { valor, reparado: false };
+    const forma = esquema;
+    if (forma.type !== "object" || forma.properties === null || typeof forma.properties !== "object") {
+        return { valor, reparado: false };
+    }
+    const propiedades = forma.properties;
+    const cerrado = forma.additionalProperties === false;
+    let reparado = false;
+    const salida = {};
+    for (const [clave, actual] of Object.entries(valor)) {
+        const propEsquema = propiedades[clave];
+        if (!propEsquema) {
+            if (cerrado) {
+                reparado = true; // campo de más: se quita
+                continue;
+            }
+            salida[clave] = actual;
+            continue;
+        }
+        if (typeof actual === "string" && propEsquema.type === "number") {
+            const convertido = comoNumero(actual);
+            if (convertido !== undefined) {
+                salida[clave] = convertido;
+                reparado = true;
+                continue;
+            }
+        }
+        if (typeof actual === "string" && propEsquema.type === "boolean") {
+            const convertido = comoBooleano(actual);
+            if (convertido !== undefined) {
+                salida[clave] = convertido;
+                reparado = true;
+                continue;
+            }
+        }
+        salida[clave] = actual;
+    }
+    return { valor: salida, reparado };
+}
+/**
+ * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`
+ * a los campos de texto indicados (los que un modelo puede mandar doblemente
+ * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye
+ * un campo de texto cuando el JSON reparado es un objeto o array — un valor
+ * de texto que por casualidad parsea como número o booleano ("42", "true") se
+ * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso
+ * decir, no un valor doblemente serializado.
+ */
+export function repararArgumentos(esquema, camposTexto = []) {
+    return (args) => {
+        if (args === null || typeof args !== "object")
+            return args;
+        let objeto = args;
+        let huboReparoDeTexto = false;
+        for (const campo of camposTexto) {
+            const bruto = objeto[campo];
+            if (typeof bruto !== "string")
+                continue;
+            const parseado = repararJSON(bruto);
+            if (parseado && parseado.valor !== null && typeof parseado.valor === "object") {
+                objeto = { ...objeto, [campo]: parseado.valor };
+                huboReparoDeTexto = true;
+            }
+        }
+        const { valor, reparado } = repararConEsquema(esquema, objeto);
+        return (huboReparoDeTexto || reparado ? valor : args);
+    };
+}
+//# sourceMappingURL=reparar-argumentos.js.map

package/dist/core/workflows/contrato/reparar-argumentos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reparar-argumentos.js","sourceRoot":"","sources":["../../../../src/core/workflows/contrato/reparar-argumentos.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Reparación de argumentos de tool mal formados, ANTES de gastar un turno en\n * un error de validación.\n *\n * Dos capas, deliberadamente separadas porque arreglan cosas distintas:\n *\n * 1. `repararJSON` — un campo de texto que debería ser un objeto/array llega\n *    con una coma colgante o doblemente serializado (fallos típicos de LLM).\n *    Parseo tolerante con UN solo intento de arreglo; nunca reescribe\n *    comillas simples ni añade comillas a claves sueltas — eso puede corromper\n *    contenido legítimo (código, texto con comillas), y aquí perder el atajo\n *    es barato, pero corromper datos no lo es.\n *\n * 2. `repararConEsquema` — campo de más (`additionalProperties: false`) y\n *    número/booleano-como-cadena, en las propiedades del NIVEL SUPERIOR del\n *    objeto. Lee `type`/`properties`/`additionalProperties` directamente del\n *    esquema en vez de delegar en `Value.Clean`/`Value.Convert` de\n *    `typebox/value`: esas dos SOLO reconocen esquemas construidos con\n *    `Type.Object(...)` (llevan una marca interna de \"tipo de nodo\" que\n *    `JSON.stringify` no serializa); un esquema declarado a mano en YAML\n *    (`outputSchema:` del frontmatter de un agente, parseado a un objeto\n *    plano) NO la lleva, y Clean/Convert se quedan calladas sin tocar nada —\n *    un \"no pude\" disfrazado de éxito, descubierto ejecutándolo de verdad, no\n *    leyendo la documentación. Leer la forma JSON a pelo funciona igual para\n *    los dos orígenes, porque ambos SON JSON Schema plano una vez\n *    serializados.\n *\n *    Nunca inventa un valor para un campo que no se puede convertir de\n *    verdad (una cadena \"abc\" en un campo number se queda \"abc\", no se\n *    convierte en `0`) — un valor inventado en silencio es peor que el error\n *    que reemplaza, exactamente el defecto que la regla del proyecto prohíbe\n *    (que \"no pude\" se lea como éxito).\n */\nimport type { TSchema } from \"typebox\";\n\n/** Quita una coma colgante antes de `}`/`]` — el error de JSON más común de un LLM. */\nfunction quitarComaColgante(texto: string): string {\n\treturn texto.replace(/,(\\s*[}\\]])/g, \"$1\");\n}\n\nexport interface JSONReparado {\n\tvalor: unknown;\n\t/** true si hizo falta el arreglo de coma colgante (el parseo directo falló). */\n\treparado: boolean;\n}\n\n/**\n * Parseo tolerante de JSON: intento directo y, si falla, un único intento\n * tras quitar comas colgantes. `undefined` si ninguno de los dos vale —\n * \"no pude repararlo\", no \"el valor es nulo\".\n */\nexport function repararJSON(texto: string): JSONReparado | undefined {\n\ttry {\n\t\treturn { valor: JSON.parse(texto), reparado: false };\n\t} catch {\n\t\t// sigue con el intento de arreglo\n\t}\n\tconst sinComa = quitarComaColgante(texto);\n\tif (sinComa === texto) return undefined;\n\ttry {\n\t\treturn { valor: JSON.parse(sinComa), reparado: true };\n\t} catch {\n\t\treturn undefined;\n\t}\n}\n\nexport interface ValorReparado {\n\tvalor: unknown;\n\t/** true si se quitó algún campo de más o se convirtió algún tipo. */\n\treparado: boolean;\n}\n\ninterface FormaObjeto {\n\ttype?: unknown;\n\tproperties?: Record<string, { type?: unknown }>;\n\tadditionalProperties?: unknown;\n}\n\nfunction comoNumero(texto: string): number | undefined {\n\tif (texto.trim() === \"\") return undefined;\n\tconst n = Number(texto);\n\treturn Number.isFinite(n) ? n : undefined;\n}\n\nfunction comoBooleano(texto: string): boolean | undefined {\n\tif (texto === \"true\") return true;\n\tif (texto === \"false\") return false;\n\treturn undefined;\n}\n\n/**\n * Repara `valor` contra `esquema`: quita campos de más del nivel superior\n * cuando el esquema es cerrado (`additionalProperties: false`) y convierte\n * número-como-cadena / booleano-como-cadena en las propiedades declaradas,\n * SOLO cuando la conversión es real. Sin recursión: opera en el objeto de\n * argumentos de una tool, que es plano por construcción.\n */\nexport function repararConEsquema(esquema: TSchema, valor: unknown): ValorReparado {\n\tif (valor === null || typeof valor !== \"object\" || Array.isArray(valor)) return { valor, reparado: false };\n\tconst forma = esquema as FormaObjeto;\n\tif (forma.type !== \"object\" || forma.properties === null || typeof forma.properties !== \"object\") {\n\t\treturn { valor, reparado: false };\n\t}\n\tconst propiedades = forma.properties;\n\tconst cerrado = forma.additionalProperties === false;\n\tlet reparado = false;\n\tconst salida: Record<string, unknown> = {};\n\tfor (const [clave, actual] of Object.entries(valor as Record<string, unknown>)) {\n\t\tconst propEsquema = propiedades[clave];\n\t\tif (!propEsquema) {\n\t\t\tif (cerrado) {\n\t\t\t\treparado = true; // campo de más: se quita\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tsalida[clave] = actual;\n\t\t\tcontinue;\n\t\t}\n\t\tif (typeof actual === \"string\" && propEsquema.type === \"number\") {\n\t\t\tconst convertido = comoNumero(actual);\n\t\t\tif (convertido !== undefined) {\n\t\t\t\tsalida[clave] = convertido;\n\t\t\t\treparado = true;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tif (typeof actual === \"string\" && propEsquema.type === \"boolean\") {\n\t\t\tconst convertido = comoBooleano(actual);\n\t\t\tif (convertido !== undefined) {\n\t\t\t\tsalida[clave] = convertido;\n\t\t\t\treparado = true;\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t}\n\t\tsalida[clave] = actual;\n\t}\n\treturn { valor: salida, reparado };\n}\n\n/**\n * `prepareArguments` genérico para un `ToolDefinition`: aplica `repararJSON`\n * a los campos de texto indicados (los que un modelo puede mandar doblemente\n * serializados) y luego `repararConEsquema` al objeto entero. Solo sustituye\n * un campo de texto cuando el JSON reparado es un objeto o array — un valor\n * de texto que por casualidad parsea como número o booleano (\"42\", \"true\") se\n * deja tal cual: ahí el texto original es casi siempre lo que el modelo quiso\n * decir, no un valor doblemente serializado.\n */\nexport function repararArgumentos<T = unknown>(esquema: TSchema, camposTexto: string[] = []): (args: unknown) => T {\n\treturn (args: unknown): T => {\n\t\tif (args === null || typeof args !== \"object\") return args as T;\n\t\tlet objeto = args as Record<string, unknown>;\n\t\tlet huboReparoDeTexto = false;\n\t\tfor (const campo of camposTexto) {\n\t\t\tconst bruto = objeto[campo];\n\t\t\tif (typeof bruto !== \"string\") continue;\n\t\t\tconst parseado = repararJSON(bruto);\n\t\t\tif (parseado && parseado.valor !== null && typeof parseado.valor === \"object\") {\n\t\t\t\tobjeto = { ...objeto, [campo]: parseado.valor };\n\t\t\t\thuboReparoDeTexto = true;\n\t\t\t}\n\t\t}\n\t\tconst { valor, reparado } = repararConEsquema(esquema, objeto);\n\t\treturn (huboReparoDeTexto || reparado ? valor : args) as T;\n\t};\n}\n"]}