@ancleto/spec 0.6.23 → 0.6.24

package/README.md

@@ -228,6 +228,8 @@ Cada entrada tiene un `scope`: `project` (default, entra en `<ProjectMemoryRules
 
 > El mismo motor se puede consultar a mano desde la terminal: `ancleto memory context --scope project`. El archivo `.ancleto/working-context.md` que lee el orquestador se regenera solo en `init`, `install --project` y `upgrade`.
 
+**Dos memorias, sin mezcla.** La memoria **del repositorio** (esta, `.ancleto/memory.db`) guarda reglas y decisiones del proyecto y se comparte con el equipo. Si el runtime expone además una memoria **del agente** (por ejemplo engram, habilitable con `--with-engram`), esa guarda notas de sesión, no del repo. **Una entrada vive en una sola**: si un futuro agente del equipo debería encontrarla, va al repo.
+
 ---
 
 ## Comandos del ciclo SDD en tu IDE

package/agents/memory-keeper.md

@@ -20,6 +20,8 @@ You are the single owner of the repository's memory (`.ancleto/memory.db`, SQLit
 
 The memory is shared across sessions: what you write, someone else recalls months later, in another change, without today's context. A wrong or noisy entry is worse than no entry, because it is retrieved as precedent.
 
+**Boundary:** the repository memory (yours) is distinct from any *agent/session* memory service the runtime may expose (e.g. engram). Repo rules and decisions live here, never duplicated there; transient, personal session notes belong to that other service, not here. When in doubt, it goes here — this is the one that outlives the repo and is shared with the team. The frontier is documented for projects in `AGENTS.md`.
+
 ## Rule vs Decision
 
 Classify every candidate BEFORE choosing the tool:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ancleto/spec",
-  "version": "0.6.23",
+  "version": "0.6.24",
   "description": "Orquestador SDD liviano con subagentes optimizados para costo/tokens",
   "type": "module",
   "bin": {

package/src/cli/index.js

@@ -352,15 +352,40 @@ function mergeLocked(source, local, filename) {
   let result = local
   for (const [name, sourceBlock] of blocks) {
     const replaced = replaceLockedBlock(result, name, sourceBlock)
-    if (replaced === null) {
+    if (replaced !== null) {
+      result = replaced
+      continue
+    }
+    // Si el nombre del bloque aparece igual en el archivo (p. ej. tag de cierre faltante),
+    // esta mal formado: se avisa y NO se toca, para no duplicar contenido.
+    const nameSeen = new RegExp(`<!--\\s*LOCKED:\\s*${escapeRe(name)}\\s*-->`).test(result)
+    if (nameSeen) {
       console.warn(`ancleto: no se pudo actualizar el bloque LOCKED "${name}" en ${filename} (tags ausentes o mal formados)`)
+      continue
+    }
+    // El bloque es nuevo (feature agregada al template): se inserta sin tocar el resto.
+    const anchor = findInsertAnchor(result, source, name)
+    if (anchor === null) {
+      console.warn(`ancleto: no se pudo insertar el bloque LOCKED "${name}" en ${filename}`)
     } else {
-      result = replaced
+      result = result.slice(0, anchor) + sourceBlock + '\n\n' + result.slice(anchor)
     }
   }
   return result
 }
 
+// Punto de insercion para un bloque LOCKED nuevo: justo antes del bloque LOCKED
+// que lo sigue en el template, o al final del archivo si es el ultimo.
+function findInsertAnchor(local, source, name) {
+  const order = [...extractLockedBlocks(source).keys()]
+  const nextInSource = order[order.indexOf(name) + 1]
+  if (nextInSource && extractLockedBlocks(local).has(nextInSource)) {
+    const at = local.search(new RegExp(`<!--\\s*LOCKED:\\s*${escapeRe(nextInSource)}\\s*-->`))
+    if (at >= 0) return at
+  }
+  return local.length
+}
+
 async function copyTemplates(projectDir) {
   const dest = join(projectDir, '.opencode')
   await copyAssets(dest)

package/templates/AGENTS.md

@@ -50,6 +50,22 @@ conflicto, prevalece el diseño vigente.
 - Si la memoria contradice el estado actual del código o los guardrails de este archivo,
   reportá la discrepancia en lugar de aplicarla a ciegas.
 
+<!-- LOCKED: memory-boundary -->
+### Frontera: memoria del repo vs memoria del agente
+
+Hay **dos memorias distintas** y no se mezclan:
+
+| Memoria | Qué guarda | Dónde vive | Herramientas |
+|---|---|---|---|
+| **Del repositorio** | Reglas y decisiones **del proyecto**: convenciones, contratos, por qué se eligió algo | `.ancleto/memory.db` (versionable con el equipo) | `searchMemory`, `recordRule`, `recordDecision` |
+| **Del agente** (si está habilitada) | Notas **de sesión/agente**: observaciones transitorias, contexto entre compactaciones | Servicio externo del agente | Las de ese servicio (p. ej. engram) |
+
+Regla: **una entrada vive en una sola memoria, nunca en ambas.** Si es una decisión o regla
+que un futuro agente del equipo debería encontrar → memoria del repo. Si es una nota personal
+de la sesión → memoria del agente. Ante la duda, va al repo: es la que sobrevive al repo y se
+comparte.
+<!-- /LOCKED: memory-boundary -->
+
 ## Flujo Spec-Driven (aspec)
 
 - **Cambios con scope incierto / arquitectura**: Crear artifacts en `aspec/changes/<name>/`.