orquestra-mcp 1.61.0 → 1.70.0

package/README.md

@@ -1,6 +1,6 @@
 # orquestra-mcp
 
-Servidor MCP (Model Context Protocol) para Orquestra. Expone **158 tools**
+Servidor MCP (Model Context Protocol) para Orquestra. Expone **161 tools**
 (conteo al 24 oct 2026, v1.49.0; la lista real está en `src/server.mjs`)
 que llaman a la API de `orquestra-infra`: lectura de contexto/dashboard/
 workspace/infra/paridad/listados, escritura de tareas/ideas/changelog/
@@ -141,6 +141,17 @@ claude mcp add orquestra \
   -- npx -y orquestra-mcp@latest
 ```
 
+## Novedades 1.66.0 (ORQ-532..535)
+
+- `close_task({id, comment, completeChecklist?, waiveVerifications?})`: cierra una tarea desde cualquier estatus
+  recorriendo el flujo (camino más corto por `nextIds` hasta el final, pasando por "En revisión"); un solo
+  `comment` (en el último paso). Respeta las guardas de checklist/verificaciones.
+- `get_tool_guide({topic})`: reglas completas de `update_task`, `create_task`, `update_tasks`, `close_task` y
+  `related_impact`; las descripciones de esas tools son cortas a propósito (test de tope en `test/mejorasMcp.test.mjs`).
+- `update_tasks` acepta `compact:true` (recomendado): cada resultado trae solo `{ index, id, ok, status, shortCode, statusId, relatedImpact?, unresolvedLinks?, error? }`.
+- `create_task` acepta `checklist: [{text, done?, assignedTo?}]` y responde `checklistCount` (y `checklistFailed` si algún ítem falló).
+- `search` documenta `statusId`/`tags` en los resultados (requiere la API con ORQ-536).
+
 ## Tools
 
 Lectura de contexto:
@@ -239,7 +250,7 @@ create/update sigue siendo criterio del agente y del humano.
 
 ## Estado
 
-158 tools (ver arriba): lectura (contexto, dashboard, workspace, infra, paridad, standup,
+161 tools (ver arriba): lectura (contexto, dashboard, workspace, infra, paridad, standup,
 sync report, setup guide, playbooks de etapa y de plataforma, catálogo de
 skills, search) + `list_*` de cada colección + creación/edición de tareas
 (con checklist, verificaciones por plataforma, tiempo, adjuntos, merge), ideas (con comentarios), notas,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "orquestra-mcp",
-  "version": "1.61.0",
-  "description": "Servidor MCP de Orquestra -- 135 tools para leer y escribir tareas, ideas, changelog, infraestructura, contenido, QA y más desde un agente de IA",
+  "version": "1.70.0",
+  "description": "Servidor MCP de Orquestra -- 161 tools para leer y escribir tareas, ideas, changelog, infraestructura, contenido, QA y más desde un agente de IA",
   "type": "module",
   "bin": {
     "orquestra-mcp": "bin/orquestra-mcp.mjs"

package/src/api.mjs

@@ -80,6 +80,10 @@ export async function apiPost(config, path, { projectId, ...body }, query = {})
   return request(buildUrl(config, path, { projectId, ...query }), { method: 'POST', headers: jsonHeaders(config), body: JSON.stringify(body) })
 }
 
+export async function apiPut(config, path, { projectId, ...body }, query = {}) {
+  return request(buildUrl(config, path, { projectId, ...query }), { method: 'PUT', headers: jsonHeaders(config), body: JSON.stringify(body) })
+}
+
 export async function apiPatch(config, path, { projectId, id, ...body }, query = {}) {
   return request(buildUrl(config, `${path}/${id}`, { projectId, ...query }), { method: 'PATCH', headers: jsonHeaders(config), body: JSON.stringify(body) })
 }
@@ -101,8 +105,8 @@ export async function apiDelete(config, path, { projectId, id }, query = {}) {
 
 // DELETE sobre un recurso singleton SIN id en la ruta (ej. /v1/client-portal,
 // ORQ-332) -- mismo criterio que apiPatchPath.
-export async function apiDeletePath(config, path, { projectId }) {
-  return request(buildUrl(config, path, { projectId }), { method: 'DELETE', headers: auth(config) })
+export async function apiDeletePath(config, path, { projectId, ...query }) {
+  return request(buildUrl(config, path, { projectId, ...query }), { method: 'DELETE', headers: auth(config) })
 }
 
 // PUT crudo a una presigned URL de S3 (createAttachmentUploadUrl en

package/src/closePath.mjs

@@ -0,0 +1,65 @@
+// ORQ-532: lógica pura de close_task. La API no recorre estatus sola (cada estatus solo permite pasar a su
+// `nextIds`), así que cerrar una tarea que está en Backlog/Bloqueado/etc. exige varios PATCH. Aquí se calcula
+// el camino más corto hacia el estatus de cierre normal (final, no cancelado ni archivo), sin tocar la red.
+
+const isClosed = s => !!(s && (s.isFinal || s.isCancel || s.isArchive))
+const isReview = s => /revisi[oó]n|review/i.test(s?.name || '')
+
+/** Normaliza la respuesta de GET /v1/statuses (arreglo directo o { items }). */
+export function normalizeStatuses(data) {
+  const list = Array.isArray(data) ? data : Array.isArray(data?.items) ? data.items : Array.isArray(data?.statuses) ? data.statuses : []
+  return list.filter(s => s && s.id)
+}
+
+/** Estatus de cierre normal: final y ni cancelado ni archivo. */
+export function closeTargets(statuses) {
+  return statuses.filter(s => s.isFinal && !s.isCancel && !s.isArchive)
+}
+
+/** BFS desde `fromId` por nextIds; no transita por estatus cerrados (final/cancelado/archivo) salvo como destino.
+ *  Devuelve el camino más corto como arreglo de estatus (sin incluir el origen) hacia `targetId`, o null. */
+function shortestPath(byId, fromId, targetId) {
+  const prev = new Map([[fromId, null]])
+  const queue = [fromId]
+  while (queue.length) {
+    const cur = queue.shift()
+    if (cur === targetId) break
+    for (const nid of byId.get(cur)?.nextIds || []) {
+      const next = byId.get(nid)
+      if (!next || prev.has(nid)) continue
+      if (isClosed(next) && nid !== targetId) continue
+      prev.set(nid, cur)
+      queue.push(nid)
+    }
+  }
+  if (!prev.has(targetId)) return null
+  const out = []
+  for (let id = targetId; id !== fromId; id = prev.get(id)) out.unshift(byId.get(id))
+  return out
+}
+
+/**
+ * @param {object[]} statuses estatuses del proyecto ({ id, name, order, nextIds, isFinal, isCancel, isArchive })
+ * @param {string} fromId estatus actual de la tarea
+ * @returns {{ alreadyClosed: true, current: object } | { path: object[], target: object } | { error: string }}
+ */
+export function findClosePath(statuses, fromId) {
+  const byId = new Map(statuses.map(s => [s.id, s]))
+  const current = byId.get(fromId)
+  if (!current) return { error: `El estatus actual de la tarea (${fromId}) no existe en el proyecto` }
+  if (isClosed(current)) return { alreadyClosed: true, current }
+  const targets = closeTargets(statuses)
+  if (!targets.length) return { error: 'El proyecto no tiene un estatus final (isFinal) al que cerrar' }
+  const candidates = targets
+    .map(t => ({ target: t, path: shortestPath(byId, fromId, t.id) }))
+    .filter(c => c.path)
+  if (!candidates.length) {
+    return { error: `No hay camino por nextIds desde "${current.name}" hasta un estatus final (${targets.map(t => `"${t.name}"`).join(', ')}). Revisa el flujo con list_statuses.` }
+  }
+  // Más corto; a igual largo, el que pasa por "En revisión" (flujo normal de cierre); luego el de menor order.
+  candidates.sort((a, b) =>
+    a.path.length - b.path.length
+    || Number(b.path.some(isReview)) - Number(a.path.some(isReview))
+    || (a.target.order ?? 0) - (b.target.order ?? 0))
+  return { path: candidates[0].path, target: candidates[0].target }
+}