@ingeniomaps/cauce 0.1.0

package/engine/integrations/state.js

@@ -0,0 +1,237 @@
+'use strict'
+
+const crypto = require('node:crypto')
+const fs = require('node:fs')
+const path = require('node:path')
+const F = require('../core/files')
+
+const STATES = ['context', 'pending', 'ready', 'rejected', 'promoted']
+const CRITICAL_FIELDS = [
+  'summary',
+  'description',
+  'type',
+  'status',
+  'assignee',
+  'parent',
+  'components',
+  'labels',
+]
+const CATEGORIES = {
+  epic: 'epics',
+  story: 'stories',
+  task: 'tasks',
+  'sub-task': 'subtasks',
+  subtask: 'subtasks',
+}
+
+const sha256 = (value) => {
+  return crypto.createHash('sha256').update(String(value)).digest('hex')
+}
+
+function frontmatter(text) {
+  const block = (String(text).match(/^---\s*\n([\s\S]*?)\n---/) || [])[1] || ''
+  const values = {}
+  for (const line of block.split('\n')) {
+    const match = line.match(/^([A-Za-z][\w-]*):\s*(.*)$/)
+    if (match) values[match[1]] = match[2].trim().replace(/^['"]|['"]$/g, '')
+  }
+  return values
+}
+
+function replaceField(text, name, value) {
+  const line = new RegExp(`^${name}:.*$`, 'm')
+  return line.test(text) ? text.replace(line, `${name}: ${value}`) : text
+}
+
+function sections(text) {
+  const body = String(text).replace(/^---[\s\S]*?---\s*/, '')
+  const title = ((body.match(/^#\s+(.+)$/m) || [])[1] || '').trim()
+  const result = { title }
+  const names = ['Descripción', 'Aceptación', 'Comentarios', 'Decisiones', 'Problemas de preparación']
+  for (const [index, name] of names.entries()) {
+    const following = names.slice(index + 1).map(escapeRegex).join('|')
+    const end = following ? `(?=^##\\s+(?:${following})\\s*$|(?![\\s\\S]))` : '(?![\\s\\S])'
+    const pattern = new RegExp(`^##\\s+${escapeRegex(name)}\\s*\\n([\\s\\S]*?)${end}`, 'im')
+    result[name] = ((body.match(pattern) || [])[1] || '').trim()
+  }
+  return result
+}
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function categoryOf(item) {
+  return CATEGORIES[String(item.type || '').toLowerCase()] || 'items'
+}
+
+function roleOf(item, config) {
+  const envName = config.candidateAssigneeEnv
+  if (!envName) return 'candidate'
+  const expected = process.env[envName]
+  if (!expected) throw new Error(`Falta la variable ${envName} para resolver candidatos`)
+  return item.assignee && item.assignee.accountId === expected ? 'candidate' : 'context'
+}
+
+function remoteView(item) {
+  return Object.fromEntries(CRITICAL_FIELDS.map((field) => [field, normalize(item[field])]))
+}
+
+function localView(draft) {
+  const parsed = sections(draft)
+  return {
+    summary: normalize(parsed.title),
+    description: normalize(parsed.Descripción),
+  }
+}
+
+function normalize(value) {
+  if (Array.isArray(value)) return [...value].map(normalize).sort(compareJson)
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, normalize(value[key])]))
+  }
+  return value === undefined || value === null ? '' : value
+}
+
+function compareJson(left, right) {
+  return JSON.stringify(left).localeCompare(JSON.stringify(right))
+}
+
+function same(left, right) {
+  return JSON.stringify(normalize(left)) === JSON.stringify(normalize(right))
+}
+
+function derive(snapshot, draft) {
+  const base = snapshot.sync.base || remoteView(snapshot.item)
+  const remote = remoteView(snapshot.item)
+  const local = localView(draft)
+  const incoming = CRITICAL_FIELDS.filter((field) => !same(remote[field], base[field]))
+  const outgoing = ['summary', 'description'].filter((field) => !same(local[field], base[field]))
+  return {
+    incoming,
+    outgoing,
+    conflict: incoming.filter((field) => outgoing.includes(field)),
+    diverged: frontmatter(draft).state === 'promoted' && incoming.length > 0,
+  }
+}
+
+function renderDraft(item, config, state = 'pending') {
+  const service = config.serviceFrom === 'component' && item.components.length === 1
+    ? item.components[0]
+    : ''
+  const acceptance = item.acceptance || 'Por definir.'
+  const issues = []
+  if (!item.acceptance) issues.push('La incidencia no contiene aceptación concreta.')
+  if (!service) issues.push('Debe definirse un servicio único para la promoción.')
+  if (!issues.length) issues.push('Ninguno detectado automáticamente.')
+  return `---
+provider: jira
+remote: ${item.key}
+type: ${item.type}
+state: ${state}
+service: "${service}"
+promotionKind: ""
+promotionEpic: ""
+promotionCriteria: ""
+promotedAt: ""
+---
+
+# ${item.summary}
+
+## Descripción
+
+${item.description || 'Sin descripción.'}
+
+## Aceptación
+
+${acceptance}
+
+## Comentarios
+
+- Contexto local; nunca se envía al proveedor.
+
+## Decisiones
+
+- Definir destino de promoción.
+
+## Problemas de preparación
+
+${issues.map((issue) => `- ${issue}`).join('\n')}
+`
+}
+
+function readStaging(root, provider = '') {
+  const staging = path.join(root, 'integrations', provider, 'staging')
+  const items = []
+  let categories = []
+  try { categories = fs.readdirSync(staging, { withFileTypes: true }) } catch { return items }
+  for (const category of categories.filter((entry) => entry.isDirectory())) {
+    const categoryDir = path.join(staging, category.name)
+    if (fs.existsSync(path.join(categoryDir, 'remote.json'))) {
+      items.push({ key: category.name, category: 'legacy', dir: categoryDir })
+      continue
+    }
+    for (const entry of fs.readdirSync(categoryDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue
+      items.push({
+        key: entry.name,
+        category: category.name,
+        dir: path.join(categoryDir, entry.name),
+      })
+    }
+  }
+  return items.sort((left, right) => left.key.localeCompare(right.key))
+}
+
+function reconcile(root, provider, operation, keys = []) {
+  const selected = new Set(keys)
+  const results = []
+  for (const staged of readStaging(root, provider)) {
+    if (selected.size && !selected.has(staged.key)) continue
+    const snapshotFile = path.join(staged.dir, 'remote.json')
+    const draftFile = path.join(staged.dir, 'draft.md')
+    const snapshot = JSON.parse(fs.readFileSync(snapshotFile, 'utf8'))
+    let draft = fs.readFileSync(draftFile, 'utf8')
+    if (operation === 'reset') {
+      const state = snapshot.sync.role === 'context' ? 'context' : 'pending'
+      draft = renderDraft(snapshot.item, snapshot.sync.config || {}, state)
+      snapshot.sync.base = remoteView(snapshot.item)
+      snapshot.sync.baseAt = new Date().toISOString()
+    } else if (operation === 'reconcile') {
+      snapshot.sync.base = remoteView(snapshot.item)
+      snapshot.sync.baseAt = new Date().toISOString()
+    } else if (operation !== 'rebase') {
+      throw new Error(`Operación de reconciliación desconocida: ${operation}`)
+    }
+    const canonicalState = snapshot.sync.role === 'context' ? 'context' : 'pending'
+    snapshot.sync.draftBaseHash = sha256(
+      renderDraft(snapshot.item, snapshot.sync.config || {}, canonicalState),
+    )
+    snapshot.sync.draftChanged = sha256(draft) !== snapshot.sync.draftBaseHash
+    F.atomicWrite(draftFile, draft)
+    F.atomicWriteJson(snapshotFile, snapshot)
+    results.push(staged.key)
+  }
+  if (selected.size && results.length !== selected.size) {
+    const missing = [...selected].filter((key) => !results.includes(key))
+    throw new Error(`No se encontraron en staging: ${missing.join(', ')}`)
+  }
+  return results
+}
+
+module.exports = {
+  CRITICAL_FIELDS,
+  STATES,
+  categoryOf,
+  derive,
+  frontmatter,
+  localView,
+  readStaging,
+  reconcile,
+  remoteView,
+  renderDraft,
+  replaceField,
+  roleOf,
+  sections,
+  sha256,
+}

package/engine/integrations/writeback.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const P = require('./proposals')
+const S = require('./state')
+
+const WRITABLE_STATES = ['pending', 'ready', 'promoted']
+
+function plan(root, provider, config) {
+  const updates = []
+  const creates = []
+  const blocked = []
+  for (const staged of S.readStaging(root, provider)) {
+    const snapshot = JSON.parse(fs.readFileSync(path.join(staged.dir, 'remote.json'), 'utf8'))
+    const draft = fs.readFileSync(path.join(staged.dir, 'draft.md'), 'utf8')
+    const fields = S.frontmatter(draft)
+    const signals = S.derive(snapshot, draft)
+    if (!signals.outgoing.length) continue
+    const refusal = reason => blocked.push({
+      key: staged.key,
+      fields: signals.outgoing,
+      reason,
+    })
+    if (snapshot.sync.role !== 'candidate') {
+      refusal('solo los candidatos pueden producir una escritura')
+      continue
+    }
+    if (snapshot.sync.missingFromRemote) {
+      refusal('el item ya no está presente en el remoto')
+      continue
+    }
+    if (signals.conflict.length) {
+      refusal(`conflicto en ${signals.conflict.join(', ')}; requiere reset o reconcile`)
+      continue
+    }
+    if (!WRITABLE_STATES.includes(fields.state)) {
+      refusal(`state=${fields.state || 'desconocido'} no autoriza escritura`)
+      continue
+    }
+    const local = S.localView(draft)
+    const changed = Object.fromEntries(
+      signals.outgoing.map((field) => [field, local[field]]),
+    )
+    updates.push({ key: staged.key, fields: changed })
+  }
+  for (const proposal of P.read(root, provider)) {
+    if (proposal.fields.state === 'published') continue
+    if (proposal.fields.state !== 'approved') {
+      blocked.push({ key: proposal.file, reason: `state=${proposal.fields.state}` })
+      continue
+    }
+    creates.push({
+      proposal: proposal.file,
+      parent: proposal.fields.parent || '',
+      type: proposal.fields.type,
+      service: proposal.fields.service,
+      summary: proposal.summary,
+      description: proposal.description,
+    })
+  }
+  return {
+    provider,
+    writeBack: config.writeBack === true,
+    wouldWrite: config.writeBack === true ? updates.length + creates.length : 0,
+    updates,
+    creates,
+    blocked,
+  }
+}
+
+function summarize(result) {
+  return {
+    ...result,
+    updates: result.updates.map((update) => ({
+      key: update.key,
+      fields: Object.fromEntries(Object.entries(update.fields).map(([name, value]) => {
+        return [name, `${String(value).length} chars`]
+      })),
+    })),
+    creates: result.creates.map((entry) => ({
+      proposal: entry.proposal,
+      parent: entry.parent,
+      type: entry.type,
+      service: entry.service,
+    })),
+  }
+}
+
+module.exports = { plan, summarize }

package/engine/planning/business-rules.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const REQUIRED = ['## Reglas', '## Por qué existe cada regla', '## Historial']
+const ID_PATTERN = /\|\s*(BR-[A-Z0-9]+-\d{3})\s*\|/g
+
+function markdownFiles(root) {
+  if (!fs.existsSync(root)) return []
+  const files = []
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    const current = path.join(root, entry.name)
+    if (entry.isDirectory()) files.push(...markdownFiles(current))
+    else if (entry.name.endsWith('.md') && !['README.md', '000-template.md'].includes(entry.name)) {
+      files.push(current)
+    }
+  }
+  return files.sort()
+}
+
+function validate(root) {
+  const errors = []
+  const ids = new Map()
+  for (const file of markdownFiles(root)) {
+    const relative = path.relative(path.dirname(root), file)
+    const source = fs.readFileSync(file, 'utf8')
+    if (!/> \*\*Dominio:\*\* .+ \| \*\*Estado:\*\* .+ \| \*\*Actualizado:\*\* \d{4}-\d{2}-\d{2}/.test(source)) {
+      errors.push(`${relative}: falta metadata Dominio/Estado/Actualizado`)
+    }
+    for (const heading of REQUIRED) {
+      if (!source.includes(heading)) errors.push(`${relative}: falta ${heading}`)
+    }
+    const found = [...source.matchAll(ID_PATTERN)].map((match) => match[1])
+    if (!found.length) errors.push(`${relative}: no declara reglas BR-DOM-NNN`)
+    for (const id of found) {
+      if (ids.has(id)) errors.push(`${relative}: ${id} duplicado en ${ids.get(id)}`)
+      else ids.set(id, relative)
+    }
+  }
+  return errors
+}
+
+module.exports = { markdownFiles, validate }

package/engine/planning/contracts.js

@@ -0,0 +1,90 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const TEST_TRACE = /^(?:n\/a\s*[—-]\s*.+|(?:A|C\d+)\s*(?:→|->)\s*\S.+)$/i
+const DECISION_TRACE = /\[(?:fuente|supuesto):\s*[^\]]+\]/i
+const EPIC_AUXILIARY_FILES = new Set(['notes.md', 'plan.md', 'research.md', 'spec.md'])
+
+function validTestTrace(value) {
+  return String(value || '').split(/\s*;\s*/).filter(Boolean)
+    .every((item) => TEST_TRACE.test(item))
+}
+
+function validDecisionTrace(value) {
+  const text = String(value || '').trim()
+  return !text || DECISION_TRACE.test(text)
+}
+
+function validateDoneEntry(entry) {
+  const at = `${entry.source} ${entry.slug}`
+  const errors = []
+  if (!entry.tests) errors.push(`${at}: falta tests:`)
+  else if (!validTestTrace(entry.tests)) {
+    errors.push(`${at}: tests debe rastrear A/CN → prueba o justificar n/a — razón`)
+  }
+  if (!validDecisionTrace(entry.decisions)) {
+    errors.push(`${at}: decisions debe citar [fuente: ...] o [supuesto: ...]`)
+  }
+  return errors
+}
+
+function duplicates(values) {
+  return [...new Set(values.filter((value, index) => values.indexOf(value) !== index))]
+}
+
+function validateEpic(epic, done = new Set()) {
+  const at = `roadmap/${epic.file}`
+  const errors = []
+  const named = epic.file.match(/^epic-(\d{3})-/)
+  if (named && named[1] !== epic.num) {
+    errors.push(`${at}: el nombre indica ${named[1]} pero el frontmatter declara ${epic.num || 'vacío'}`)
+  }
+  for (const id of duplicates(epic.criteria.map((criterion) => criterion.id))) {
+    errors.push(`${at}: criterio duplicado ${id}`)
+  }
+  for (const slug of duplicates(epic.stories.map((story) => story.slug))) {
+    errors.push(`${at}: historia duplicada ${slug}`)
+  }
+  const covered = new Set(epic.stories.flatMap((story) => story.criteria))
+  for (const criterion of epic.criteria) {
+    if (!covered.has(criterion.id)) errors.push(`${at}: ${criterion.id} no está cubierto por ninguna historia`)
+  }
+  if (epic.status === 'closed') {
+    const missing = epic.stories.filter((story) => !done.has(story.slug))
+    if (missing.length) errors.push(`${at}: closed sin evidencia para ${missing.map((story) => story.slug).join(', ')}`)
+  }
+  return errors
+}
+
+function validateRoadmapStructure(dir) {
+  const roadmap = path.join(dir, 'roadmap')
+  let entries = []
+  try { entries = fs.readdirSync(roadmap, { withFileTypes: true }) } catch { return ['falta roadmap/'] }
+  const errors = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !/^epic-\d{3}-/.test(entry.name)) continue
+    const epicDir = path.join(roadmap, entry.name)
+    if (!fs.existsSync(path.join(epicDir, 'spec.md'))) {
+      errors.push(`roadmap/${entry.name}: falta spec.md`)
+    }
+    for (const child of fs.readdirSync(epicDir, { withFileTypes: true })) {
+      if (!child.isFile() || !EPIC_AUXILIARY_FILES.has(child.name)) {
+        errors.push(`roadmap/${entry.name}/${child.name}: archivo auxiliar no permitido`)
+      }
+    }
+  }
+  return errors
+}
+
+module.exports = {
+  DECISION_TRACE,
+  EPIC_AUXILIARY_FILES,
+  TEST_TRACE,
+  validDecisionTrace,
+  validTestTrace,
+  validateDoneEntry,
+  validateEpic,
+  validateRoadmapStructure,
+}

package/engine/planning/parser.js

@@ -0,0 +1,184 @@
+'use strict'
+
+// Contratos deterministas de planning; no contiene estado de proyecto.
+
+const fs = require('fs')
+const path = require('path')
+
+const EPIC_STATES = ['open', 'active', 'closed']
+const TIERS = ['directo', 'lite', 'full']
+
+function read(file) {
+  try { return fs.readFileSync(file, 'utf8') } catch { return '' }
+}
+
+function frontmatter(text) {
+  const block = (text.match(/^---\s*\n([\s\S]*?)\n---/m) || [])[1] || ''
+  const values = new Map()
+  for (const line of block.split('\n')) {
+    const match = line.match(/^([\w-]+):\s*(.*)$/)
+    if (match) values.set(match[1], match[2].trim().replace(/^['"]|['"]$/g, ''))
+  }
+  return (key) => values.get(key) || ''
+}
+
+function section(text, heading) {
+  const parts = text.split(/^##\s+/m)
+  return parts.find((part) => heading.test(part.split('\n')[0])) || ''
+}
+
+function withoutComments(text) {
+  return text.replace(/<!--[\s\S]*?-->/g, '')
+}
+
+function epicFiles(dir) {
+  const roadmap = path.join(dir, 'roadmap')
+  let entries = []
+  try { entries = fs.readdirSync(roadmap, { withFileTypes: true }) } catch { return [] }
+  const files = []
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (entry.isFile() && /^epic-\d{3}-.+\.md$/.test(entry.name)) {
+      files.push({ name: entry.name, file: path.join(roadmap, entry.name) })
+    } else if (entry.isDirectory() && /^epic-\d{3}-/.test(entry.name)) {
+      const spec = path.join(roadmap, entry.name, 'spec.md')
+      if (fs.existsSync(spec)) files.push({ name: `${entry.name}/spec.md`, file: spec })
+    }
+  }
+  return files
+}
+
+function criteriaRefs(text) {
+  const refs = []
+  const groups = [
+    ...text.matchAll(/\(\s*(?:→|->)\s*([^)]*)\)/g),
+    ...text.matchAll(/\*\(\s*criterios?\s+([^)]*)\)\*/gi),
+  ]
+  for (const group of groups) {
+    for (const match of group[1].matchAll(/C?\d+/gi)) {
+      const id = match[0].toUpperCase()
+      refs.push(id.startsWith('C') ? id : `C${id}`)
+    }
+  }
+  return [...new Set(refs)]
+}
+
+function readEpics(dir, { includeTemplates = false } = {}) {
+  return epicFiles(dir).map(({ name, file }) => {
+    const text = read(file)
+    const field = frontmatter(text)
+    const criteria = [...section(text, /Criterios/i).matchAll(/^-\s+\*\*(C\d+)(?:[^*]*)\*\*\s+[—-]\s+(.+)$/gm)]
+      .map((match) => ({ id: match[1], text: match[2].trim() }))
+    const storyPattern = new RegExp(
+      String.raw`^[-*]\s+(?:\[[ xX]\]\s+)?\*\*([^*]+)\*\*\s+([\s\S]*?)` +
+        String.raw`(?=\n[-*]\s+(?:\[[ xX]\]\s+)?\*\*|\n##|$)`,
+      'gm',
+    )
+    const stories = [...section(text, /Historias/i).matchAll(storyPattern)]
+      .map((match) => ({
+        slug: match[1].trim(),
+        text: match[2].replace(/\s+/g, ' ').trim(),
+        criteria: criteriaRefs(match[2]),
+        service: ((match[2].match(/\(service:\s*([^)]+)\)/) || [])[1] || '').trim(),
+      }))
+    return {
+      file: name,
+      path: file,
+      num: field('epic'),
+      title: field('title'),
+      status: field('status'),
+      service: field('service'),
+      criteria,
+      stories,
+      hasContext: /^##\s+Contexto relevante/im.test(text),
+    }
+  }).filter((epic) => includeTemplates || epic.status !== 'template' && epic.num !== '000')
+}
+
+function readBacklog(dir) {
+  const text = withoutComments(read(path.join(dir, 'BACKLOG.md')))
+  const milestones = []
+  let current = null
+  for (const line of text.split('\n')) {
+    const heading = line.match(/^##\s+Hito\s+([^\s]+)\s+[—-]\s+(.+)$/)
+    if (heading) {
+      current = { slug: heading[1], title: heading[2].trim(), heading: line.slice(3), tasks: [] }
+      milestones.push(current)
+      continue
+    }
+    if (/^##\s+/.test(line)) current = null
+    const task = line.match(/^-\s+\[\s\]\s+\*\*([^*]+)\*\*\s*(?:\[(directo|lite|full)\])?\s+[—-]\s+(.+)$/)
+    if (!task || !current) continue
+    const rest = task[3]
+    current.tasks.push({
+      slug: task[1].trim(), tier: task[2] || '', text: rest,
+      epic: ((rest.match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
+      service: ((rest.match(/\(service:\s*([^)]+)\)/) || [])[1] || '').trim(),
+      acceptance: ((rest.match(/_Aceptaci[oó]n:\s*([^_]+)_/i) || [])[1] || '').trim(),
+      criteria: criteriaRefs(rest),
+    })
+  }
+  return milestones
+}
+
+function doneFiles(dir) {
+  const files = [path.join(dir, 'DONE.md')]
+  const archive = path.join(dir, 'done')
+  try {
+    files.unshift(...fs.readdirSync(archive).filter((file) => /^epic-\d{3}\.md$/.test(file)).sort()
+      .map((file) => path.join(archive, file)))
+  } catch { /* no archive yet */ }
+  return files
+}
+
+function readDone(dir) {
+  const entries = []
+  for (const file of doneFiles(dir)) {
+    const text = withoutComments(read(file))
+    const donePattern = /^-\s+\[[xX]\]\s+\*\*([^*]+)\*\*([^\n]*)([\s\S]*?)(?=\n-\s+\[[xX]\]|\n##|(?![\s\S]))/gm
+    const matches = [...text.matchAll(donePattern)]
+    for (const match of matches) {
+      const body = match[3]
+      const field = (name) => ((body.match(new RegExp(`^\\s+${name}:\\s*(.+)$`, 'mi')) || [])[1] || '').trim()
+      entries.push({
+        slug: match[1].trim(),
+        epic: ((match[2].match(/\(epic:\s*(\d{3})\)/) || [])[1] || ''),
+        acceptance: field('acept'), done: field('done'), qa: field('qa'), tests: field('tests'),
+        decisions: field('decisions'), commit: field('commit'),
+        source: path.relative(dir, file), raw: match[0].trimEnd(),
+      })
+    }
+  }
+  const duplicates = entries.map((entry) => entry.slug)
+    .filter((slug, index, all) => all.indexOf(slug) !== index)
+  return { entries, set: new Set(entries.map((entry) => entry.slug)), duplicates: [...new Set(duplicates)] }
+}
+
+function readWip(dir) {
+  const text = read(path.join(dir, 'WIP.md'))
+  if (/^status:\s*IDLE/m.test(text)) return null
+  const field = frontmatter(text)
+  const task = field('task')
+  if (!task) return null
+  return {
+    task, phase: field('phase') || '?', service: field('service'),
+    complete: (text.match(/^\d+\.\s+\[[xX]\]/gm) || []).length,
+    pending: (text.match(/^\d+\.\s+\[\s\]/gm) || []).length,
+  }
+}
+
+function readInbox(dir) {
+  const result = { deuda: 0, ideas: 0, propuestas: 0, lecciones: 0 }
+  for (const part of read(path.join(dir, 'INBOX.md')).split(/^##\s+/m)) {
+    const title = part.split('\n')[0]
+    const count = (part.match(/^[-*]\s+(?:\[[ xX]\]\s+)?\*\*/gm) || []).length
+    if (/Deuda/i.test(title)) result.deuda = count
+    if (/Ideas|Visi[oó]n/i.test(title)) result.ideas = count
+    if (/Propuestas/i.test(title)) result.propuestas = count
+    if (/Lecciones/i.test(title)) result.lecciones = count
+  }
+  return result
+}
+
+module.exports = {
+  EPIC_STATES, TIERS, read, frontmatter, readEpics, readBacklog, readDone, readWip, readInbox,
+}

package/engine/schemas/ops-config.schema.json

@@ -0,0 +1,37 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Cauce engine configuration",
+  "type": "object",
+  "required": ["project", "mode", "planningDir", "workspaceRoots", "runner"],
+  "properties": {
+    "$schema": { "type": "string", "minLength": 1 },
+    "project": { "type": "string", "minLength": 1 },
+    "mode": { "enum": ["embedded", "sidecar", "toolkit"] },
+    "planningDir": { "type": "string", "minLength": 1 },
+    "workspaceRoots": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["name", "path"],
+        "properties": {
+          "name": { "type": "string", "minLength": 1 },
+          "path": { "type": "string", "minLength": 1 }
+        },
+        "additionalProperties": false
+      }
+    },
+    "runner": {
+      "type": "object",
+      "required": ["maxTaskHours", "humanCheckpointBetweenMilestones", "commitPerTask", "allowPush"],
+      "properties": {
+        "maxTaskHours": { "type": "number", "exclusiveMinimum": 0 },
+        "humanCheckpointBetweenMilestones": { "type": "boolean" },
+        "commitPerTask": { "type": "boolean" },
+        "allowPush": { "type": "boolean" }
+      },
+      "additionalProperties": false
+    }
+  },
+  "additionalProperties": false
+}