ostacky 0.10.0 → 0.10.2

package/assets/plugins/ostacky-controller/index.ts

@@ -6,7 +6,7 @@
  * MCP queda thin solo para observabilidad (get_*).
  *
  * Single source security: mirrors generados desde src/security.ts via scripts/sync-controller-core.ts
- * Cache único: getDiscoverySnapshot es único entrypoint.
+ * Discovery: `codegraph_explore` completado; no hay cache de archivo.
  * Tiered cache-friendly: isTrivial sin reemplazar system[0], suffix hint + SKIP.
  * CodeGraph preventivo: bloquea Read/Grep masivo sin Discovery hit.
  */
@@ -152,6 +152,34 @@ export function mergePluginOwnedState(fresh: any, state: any, ownedKeys: string[
   return payload
 }
 
+/**
+ * multisession-ownership-guard: hay UN state file por proyecto, así que el PENDING
+ * puede ser de otra sesión. El gate no debe congelar sesiones ajenas a esa request
+ * (antes, cualquier sesión quedaba bloqueada por la confirmación pendiente de otra).
+ *
+ * No aplica cuando no hay dueño (estado legacy), cuando el caller es el dueño, ni
+ * cuando el caller es desconocido (`event.sessionID` ausente → "default"): sin
+ * identidad no se puede probar ajeneidad.
+ */
+export function isForeignPendingOwner(state: any, sessionId: string | null | undefined): boolean {
+  const owner = state?.ownerSessionId
+  if (!owner || !sessionId || sessionId === "default") return false
+  return owner !== sessionId
+}
+
+/**
+ * Cache del gate PENDING. El cache es por `revision`, NO por dueño: si el paso de
+ * una sesión ajena dejara un ALLOW, la dueña lo reutilizaría y se saltearía su
+ * propia confirmación. Por eso un PENDING ajeno no cachea nada.
+ */
+export function nextPendingGateCache(
+  revision: number,
+  foreignPendingOwner: boolean
+): { revision: number; result: string } | null {
+  if (foreignPendingOwner) return null
+  return { revision, result: "ALLOW" }
+}
+
 /**
  * Persiste estado SIN poder pisar al MCP.
  *
@@ -228,25 +256,6 @@ function isPathInsideProject(filePath: string, directory: string): boolean {
   } catch { return false }
 }
 
-function getDiscoveryCacheHit(directory: string): boolean {
-  try {
-    const cacheDir = join(directory, ".opencode", "cache", "codegraph")
-    if (!existsSync(cacheDir)) return false
-    const files = readdirSync(cacheDir).filter((f: string) => f.startsWith("discovery-"))
-    if (files.length === 0) return false
-    // check if any file is recent (<1h) and valid
-    const now = Date.now()
-    for (const f of files) {
-      try {
-        const raw = readFileSync(join(cacheDir, f), "utf-8")
-        const data = JSON.parse(raw)
-        if (typeof data.ts === "number" && now - data.ts < 60*60*1000) return true
-      } catch {}
-    }
-    return false
-  } catch { return false }
-}
-
 function isCodegraphAvailable(directory: string): boolean {
   // If codegraph binary exists, assume OK. Otherwise fallback allows Read.
   try {
@@ -259,6 +268,231 @@ function isCodegraphAvailable(directory: string): boolean {
   } catch { return false }
 }
 
+/**
+ * ¿Este read/grep/glob esta sujeto al gate de discovery?
+ * Exenciones: docs/json/md, openspec/changes|specs, grep de literales, y archivos ya
+ * trackeados (refresh honesto post-complete necesita Read fresco sin Discovery hit).
+ */
+export function isCodeReadGated(input: {
+  isCodeFile: boolean
+  isLiteralGrep: boolean
+  isSpecTasksPath: boolean
+  isDocsPath: boolean
+  isTaskTracked: boolean
+}): boolean {
+  return (
+    input.isCodeFile &&
+    !input.isLiteralGrep &&
+    !input.isSpecTasksPath &&
+    !input.isDocsPath &&
+    !input.isTaskTracked
+  )
+}
+
+/**
+ * Predicado puro del gate de CodeGraph: ¿bloquear esta lectura de codigo?
+ *
+ * Extraido a funcion para poder testear el INVARIANTE, no el mensaje. El test anterior hacia
+ * `expect(src).toContain("Usa getDiscoverySnapshot primero")`: verificaba que el texto existiera
+ * y pasaba verde con el gate inescapable adentro (fix-codegraph-gate).
+ */
+export function shouldBlockCodeRead(input: {
+  isCodeFile: boolean
+  isLiteralGrep: boolean
+  isSpecTasksPath: boolean
+  isDocsPath: boolean
+  isTaskTracked: boolean
+  codegraphOk: boolean
+  hasDiscoveryHit: boolean
+}): boolean {
+  return isCodeReadGated(input) && input.codegraphOk && !input.hasDiscoveryHit
+}
+
+/**
+ * Tools cuyo completado constituye evidencia REAL de discovery estructural en la sesion.
+ *
+ * `codegraph_explore` es la senal fuerte: llamada real, resultado inspeccionable por el plugin.
+ * No hay cache de discovery: `getDiscoverySnapshot` nunca existió y se retiró.
+ *
+ * Historia (fix-codegraph-gate): antes la UNICA senal era `getDiscoverySnapshot`, una tool que nunca
+ * se registro ni en el plugin ni en el MCP. `hasDiscoveryHit` era siempre false y el gate bloqueaba
+ * todo read/grep/glob de codigo sin salida posible; un `codegraph_explore` completado NO lo abria,
+ * contradiciendo la instruccion "CodeGraph primero" del agente.
+ */
+export function marksDiscovery(toolName: string): boolean {
+  return (
+    toolName.includes("codegraph_explore")
+  )
+}
+
+/**
+ * Predicado puro del horizonte del gate de discovery: ¿este prompt invalida el
+ * hit estructural de la sesión?
+ *
+ * El contrato de reuso es POR REQUEST ("reuso del output ya obtenido en el request",
+ * remove-discovery-cache-phantom archivado 2026-10-19), no por sesión: la instrucción
+ * §1 del agente y record_discovery son por request; el gate era el único desalineado.
+ * Los prompts TRIVIALES no invalidan: el plugin les inyecta "No hagas Discovery"
+ * (hint :555) — limpiar el hit ahí crearía instrucción y gate contradictorias.
+ */
+export function shouldInvalidateDiscoveryHit(trivial: boolean): boolean {
+  return !trivial
+}
+
+/**
+ * Mismo criterio de "archivo de código" que el gate de read (index.ts:552),
+ * sin la cláusula de `pattern` que es específica de glob. Docs/JSON quedan fuera:
+ * un .md bajo assets/ es documentación, no código.
+ */
+export function isCodePath(p: string): boolean {
+  if (!p) return false
+  if (/\.(md|json)$/i.test(p)) return false
+  return /\.(ts|js|tsx|jsx|mts|cts)$/i.test(p) || p.includes("src/") || p.includes("assets/")
+}
+
+/**
+ * Evidencia de una corrida de shell para las tasks `test:` (change
+ * test-verification-execution). Devuelve null si el evento no permite afirmar
+ * nada: sin comando o sin `exit` numérico.
+ *
+ * NO consulta `status`: medido en OpenCode 2.0.32, `sh -c 'exit 3'` llega con
+ * `status: "completed"` y `result.metadata.status: "completed"`. El único dato
+ * veraz es `result.metadata.exit`.
+ */
+export function shellEvidence(event: any): { cmd: string; exit: number; ts: number } | null {
+  if (!event || event.tool !== "shell") return null
+  const cmd = event.input?.command
+  const exit = event.result?.metadata?.exit
+  if (typeof cmd !== "string" || !cmd.trim()) return null
+  if (typeof exit !== "number") return null
+  return { cmd: cmd.trim(), exit, ts: Date.now() }
+}
+
+/** Tools que mutan archivos: avanzan `lastMutationTs`. */
+export function isMutatingTool(tool: string): boolean {
+  return tool === "edit" || tool === "write" || tool === "patch"
+}
+
+/**
+ * Comando shell que escribe en disco. Predicado compartido por el gate de
+ * mutación y por `lastMutationTs`: si no se compartiera, un `sed -i` aprobado
+ * por el gate mutaría el código sin avanzar el timestamp, y una corrida de test
+ * previa seguiría contando como evidencia.
+ */
+export function isShellMutation(command: string): boolean {
+  if (!command) return false
+  // `2>&1`, `1>&2`, `2>/dev/null` son redirects de stderr, no mutación.
+  const cmdSansStderr = command.replace(/2>&1/g, "").replace(/1>&2/g, "").replace(/2>\s*\/dev\/null/g, "")
+  return /(^|[^0-9&])>{1,2}\s*(?!&)\S+|\bsed\b[^|;]*-i|\btruncate\b|\btee\b|\bcp\s+|\bmv\s+|\brm\s+|python.*open.*w/.test(cmdSansStderr)
+}
+
+/**
+ * Verbos cuyo output revela el CONTENIDO de un archivo. No incluye verbos que
+ * sólo mencionan paths (`bun test x.ts`, `tsc src/x.ts`, `git diff`): el gate
+ * distingue "revela" de "menciona" — ver change shell-code-read-gate.
+ */
+const SHELL_READ_VERBS = new Set([
+  "cat", "head", "tail", "sed", "awk", "grep", "rg", "ag", "ack", "less", "more",
+  "nl", "bat", "tac", "strings", "xxd", "od", "base64", "diff", "cut", "paste",
+  "sort", "uniq", "column", "expand", "fold",
+])
+
+const SHELL_WRAPPERS = new Set(["sudo", "env", "time", "command", "exec", "nohup"])
+
+/**
+ * Paths de código que `command` REVELA (no los que menciona).
+ *
+ * Fail-open por diseño: redirección => escritura, `sed -i` => escritura, verbo
+ * fuera de la allowlist => []. Un gate de shell nunca es hermético; el objetivo
+ * es quitar el bypass casual (`cat src/x.ts`), no demostrar imposibilidad.
+ * Bypass residual documentado en el spec: `git show`, `python -c`, `node -e`,
+ * `find -exec`, `xargs`.
+ */
+export function shellReadTargets(command: string): string[] {
+  if (!command) return []
+  const targets: string[] = []
+  // Split por pipes/separadores, NO por `>`: necesitamos ver la redirección.
+  const segments = command.replace(/&&/g, ";").replace(/\|\|/g, ";").split(/[|;\n]+/)
+  for (const seg of segments) {
+    const trimmed = seg
+      // Redirects de stderr no son escritura: sin esto, `cat src/x.ts 2>&1`
+      // pasaba el check `>` de abajo y se colaba del gate (bypass casual).
+      // Mismo criterio que isShellMutation, el sibling de este módulo.
+      .replace(/2>&1/g, "")
+      .replace(/1>&2/g, "")
+      .replace(/2>\s*\/dev\/null/g, "")
+      .trim()
+    if (!trimmed) continue
+    // Escritura real (cat > f, tee, heredoc): no es lectura.
+    if (/>/.test(trimmed)) continue
+    const tokens = (trimmed.match(/(?:[^\s"'`\\]+|"[^"]*"|'[^']*'|`[^`]*`)+/g) || [])
+      .map((t) => t.replace(/["'`]/g, "").replace(/\\/g, ""))
+      .filter(Boolean)
+    if (tokens.length === 0) continue
+    let i = 0
+    while (i < tokens.length && SHELL_WRAPPERS.has(tokens[i])) i++
+    const verb = tokens[i] || ""
+    const base = verb.split("/").pop() || verb
+    if (!SHELL_READ_VERBS.has(base)) continue
+    // sed -i es escritura in-place, no lectura.
+    if (base === "sed" && tokens.some((t) => t === "-i" || t.startsWith("-i") || t === "--in-place" || t.startsWith("--in-place"))) continue
+    // diff -q/--brief/--stat sólo compara metadatos: no revela contenido.
+    if (base === "diff" && tokens.some((t) => t === "-q" || t === "--quiet" || t === "--brief" || t === "--stat" || /^-[a-zA-Z]*q[a-zA-Z]*$/.test(t))) continue
+    for (const p of extractPathsFromBash(trimmed)) {
+      if (isCodePath(p)) targets.push(p)
+    }
+  }
+  return [...new Set(targets)]
+}
+
+/**
+ * Predicado puro del gate de shell: ¿leer este path por shell está EXENTO?
+ *
+ * Extraído del hook para poder testear el INVARIANTE (mismo criterio que
+ * shouldBlockCodeRead). Exenciones:
+ * 1. Paths FUERA del proyecto: no son código de este codebase (fixtures
+ *    temporales de tests, reportes generados); bloquearlos rompe pipelines sin
+ *    escape hatch — el falso positivo que el diseño prohibió.
+ * 2. Specs/docs (.md/.json, openspec, assets/docs).
+ * 3. Archivos ya trackeados en tasks/fileFingerprints/lastValidated (el refresh
+ *    honesto post-complete necesita re-leerlos).
+ */
+export function isShellPathExempt(p: string, directory: string, freshState: any): boolean {
+  if (!isPathInsideProject(p, directory)) return true
+  if (p.includes("openspec/changes") || p.includes("openspec/specs")) return true
+  if (p.includes("assets/docs") || p.includes("/docs/") || /\.md$/i.test(p) || /\.json$/i.test(p)) return true
+  try {
+    if (freshState) {
+      const fps = Object.keys(freshState.fileFingerprints || {})
+      const taskFiles = Object.values(freshState.tasks || {}).map((t: any) => t.filePath).filter(Boolean)
+      const lv: any = (freshState as any).lastValidated || null
+      const lvByFile = lv?.byFile && typeof lv.byFile === "object" ? lv.byFile : null
+      const lvPaths: string[] = [
+        ...(lvByFile ? Object.keys(lvByFile) : []),
+        ...(lv?.filePath ? [lv.filePath as string] : []),
+      ]
+      const matches = (f: string): boolean => p.endsWith(f) || f.endsWith(p) || p.includes(f) || f.includes(p)
+      if (fps.some(matches) || taskFiles.some(matches)) return true
+      if (lvPaths.some((lf) => p.endsWith(lf) || lf.endsWith(p))) return true
+    }
+  } catch {}
+  return false
+}
+
+/** Comandos `test:` declarados en taskVerifications, ya normalizados (sin prefijo). */
+export function testVerifyCommands(state: any): Set<string> {
+  const out = new Set<string>()
+  try {
+    for (const v of Object.values((state as any)?.taskVerifications || {})) {
+      if (typeof v === "string" && v.trim().startsWith("test:")) {
+        const cmd = v.trim().slice("test:".length).trim()
+        if (cmd) out.add(cmd)
+      }
+    }
+  } catch {}
+  return out
+}
+
 function jsonContent(value: unknown): { content: string } {
   try {
     return { content: JSON.stringify(value) ?? "null" }
@@ -343,9 +577,25 @@ export default {
       const sessionId: string = event.sessionID ?? "default"
       const text = (event.prompt.text ?? "").trim()
       const state = readState(directory)
+      // task-verification-integrity D4: registrar el texto ORIGINAL del usuario (antes de los
+      // hints de abajo) para que `implementation_complete({force:true})` se apoye en evidencia
+      // real y no en el audit, que lo redacta el agente. `ownedKeys` evita pisar el avance del MCP.
+      // Cada prompt lleva `ts`: el MCP sólo acepta confirmaciones POSTERIORES al último
+      // intento de force, así un "¿qué hace force:true?" viejo no abre el gate.
+      if (text && state) {
+        try {
+          const prev = Array.isArray((state as any).lastUserPrompts) ? (state as any).lastUserPrompts : []
+          ;(state as any).lastUserPrompts = [...prev, { text: text.slice(0, 500), ts: Date.now() }].slice(-5)
+          persistState(directory, state, ["lastUserPrompts"])
+        } catch {}
+      }
       const currentState = state?.state ?? "DONE"
       const trivial = isTrivial(text, currentState)
       trivialBySession.set(sessionId, trivial)
+      // Horizonte por request: prompts NO-triviales invalidan el discovery hit —
+      // la siguiente lectura de código exige un explore fresco (contrato
+      // remove-discovery-cache-phantom + instrucción §1 del agente).
+      if (shouldInvalidateDiscoveryHit(trivial)) discoveryHitByRequest.delete(sessionId)
       if (trivial) {
         // Preserve system FULL cacheable, add suffix hint to user prompt text
         const hint = "\n\n[PLUGIN HINT: Saludo trivial — responde breve sin tools. No hagas Discovery.]"
@@ -402,7 +652,9 @@ export default {
       checkCount++
       const freshState = readState(directory)
       const pendingStates = ["ROUTE_DECISION_PENDING", "EXECUTION_DECISION_PENDING", "CLARIFICATION_PENDING"]
-      if (freshState && pendingStates.includes(freshState.state)) {
+      // multisession-ownership-guard: el PENDING de OTRA sesión no congela esta sesión.
+      const foreignPendingOwner = !!freshState && isForeignPendingOwner(freshState, sessionId)
+      if (freshState && pendingStates.includes(freshState.state) && !foreignPendingOwner) {
         // cache ALLOW per revision, BLOCKED never cached
         if (lastCheck && freshState.revision === lastCheck.revision && checkCount % 5 !== 0 && lastCheck.result === "ALLOW") {
           // reuse cached ALLOW
@@ -424,7 +676,7 @@ export default {
           }
         }
       } else if (freshState) {
-        lastCheck = { revision: freshState.revision, result: "ALLOW" }
+        lastCheck = nextPendingGateCache(freshState.revision, foreignPendingOwner)
       }
 
       // ── 1.6) Engram soft gate (auditable, no BLOCK) — refuerza SHALL 1 de ostacky.md ──
@@ -519,14 +771,30 @@ export default {
               (lvFile ? lvFile.some((lf) => targetPath.endsWith(lf) || lf.endsWith(targetPath)) : false)
           }
         } catch {}
-        if (isCodeFile && !isLiteralGrep && !isSpecTasksPath && !isDocsPath && !isTaskTracked) {
-          const hasDiscoveryHit = discoveryHitByRequest.get(sessionId) ?? getDiscoveryCacheHit(directory)
-          const codegraphOk = isCodegraphAvailable(directory)
-          if (codegraphOk && !hasDiscoveryHit) {
-            // Allow if file is not indexable or trivial?
-            // Block with suggestion
-            throw new Error(`BLOCKED: Usá getDiscoverySnapshot primero — sugerencia: getDiscoverySnapshot("${targetPath || "query"}")`)
-          }
+        // Orden cheap -> caro: el path no hace I/O; codegraph y la cache en disco solo se evalúan
+        // si el path esta realmente sujeto al gate (`read`/`grep`/`glob` corren en cada turno).
+        const gated = isCodeReadGated({ isCodeFile, isLiteralGrep, isSpecTasksPath, isDocsPath, isTaskTracked })
+        const codegraphOk = gated ? isCodegraphAvailable(directory) : false
+        // Sin fallback a disco: la única evidencia válida es un codegraph_explore
+        // COMPLETADO en este request (discoveryHitByRequest; el hook "prompt"
+        // invalida el hit en cada prompt no-trivial). session.deleted también lo limpia.
+        const hasDiscoveryHit = codegraphOk ? discoveryHitByRequest.get(sessionId) === true : false
+        if (shouldBlockCodeRead({
+          isCodeFile, isLiteralGrep, isSpecTasksPath, isDocsPath, isTaskTracked, codegraphOk, hasDiscoveryHit,
+        })) {
+          // Métrica de evasión real (misma convención que engramBypassCount:648):
+          // cuántas lecturas de código saltaron el gate sin explore completado.
+          try {
+            const st = readState(directory)
+            if (st) {
+              st.codeReadBlockedCount = (st.codeReadBlockedCount || 0) + 1
+              persistState(directory, st, ["codeReadBlockedCount"])
+            }
+          } catch {}
+          try { console.warn(`[ostacky] code_read_blocked: sin codegraph_explore completado en sesión (${targetPath || "query"})`) } catch {}
+          throw new Error(
+            `BLOCKED: sin discovery estructural en esta sesión — llamá codegraph_codegraph_explore("${targetPath || "query"}") antes de Read/Grep/Glob de código`
+          )
         }
       }
 
@@ -560,12 +828,32 @@ export default {
         }
       }
 
+      // ── 3.2) CodeGraph gate para shell: leer código sin discovery → BLOCKED ──
+      // El gate de código (arriba) sólo mira read/grep/glob; `cat src/x.ts` revela
+      // lo mismo y no costaba nada. Fail-open a propósito: `read` falla cerrado
+      // porque es inequívoco; `shell` es ambiguo y un falso positivo rompe tests o
+      // builds sin escape hatch para el usuario (change shell-code-read-gate).
+      if (tool === "shell") {
+        const cmdForRead: string = args?.command || args?.cmd || ""
+        if (typeof cmdForRead === "string" && cmdForRead) {
+          const shellTargets = shellReadTargets(cmdForRead)
+          if (shellTargets.length > 0) {
+            const gatedShell = shellTargets.filter((p) => !isShellPathExempt(p, directory, freshState))
+            const codegraphOkShell = gatedShell.length > 0 ? isCodegraphAvailable(directory) : false
+            const hasDiscoveryShell = codegraphOkShell ? discoveryHitByRequest.get(sessionId) === true : false
+            if (gatedShell.length > 0 && codegraphOkShell && !hasDiscoveryShell) {
+              throw new Error(
+                `BLOCKED: sin discovery estructural en esta sesión — llamá codegraph_codegraph_explore("${gatedShell[0]}") antes de leer código por shell`
+              )
+            }
+          }
+        }
+      }
+
       // ── 3.5) Shell file-mutation gate (harden-task-integrity: shell mutante requiere validate_edit) ──
       if (tool === "shell" && freshState && ["EXECUTING_INLINE", "EXECUTING_SUBAGENTS"].includes(freshState.state)) {
         const cmdForMutation: string = args?.command || args?.cmd || ""
-        // Fix falso positivo: `2>&1`, `1>&2`, `2>/dev/null` son redirects de stderr, no mutación.
-        const cmdSansStderr = cmdForMutation.replace(/2>&1/g, "").replace(/1>&2/g, "").replace(/2>\s*\/dev\/null/g, "")
-        const isMutating = /(^|[^0-9&])>{1,2}\s*(?!&)\S+|\bsed\b[^|;]*-i|\btruncate\b|\btee\b|\bcp\s+|\bmv\s+|python.*open.*w/.test(cmdSansStderr)
+        const isMutating = isShellMutation(cmdForMutation)
         if (isMutating) {
           const mPaths = extractPathsFromBash(cmdForMutation)
           for (const p of mPaths) {
@@ -722,24 +1010,53 @@ export default {
       // Track discovery hit to allow subsequent Reads
       const tool: string = event.tool as string
       const sessionId: string = (event.sessionID ?? "default") as string
-      const resultText = event.status === "completed" && event.result ? JSON.stringify(event.result) : ""
-      if (tool.includes("getDiscoverySnapshot") || tool.includes("get_discovery_snapshot")) {
-        // if output indicates hit, mark it
+      // (fix-codegraph-gate) Evidencia REAL de discovery: un `codegraph_explore` completado en ESTE
+      // request abre el gate de lecturas de código (el hook "prompt" invalida el hit en cada
+      // prompt no-trivial). Se marca aunque el resultado venga vacío, a propósito:
+      // "CodeGraph no tiene este archivo en su índice" es justamente el caso donde el
+      // Read TIENE que poder pasar si hubo `codegraph_explore`.
+      if (marksDiscovery(tool)) {
         try {
-          const text = resultText
-          if (text && !text.includes("null") && text.length > 10) {
-            discoveryHitByRequest.set(sessionId, true)
-          }
-          // Engram hit via discovery snapshot (contiene engramHits)
-          if (text && text.includes("engramHits")) {
-            engramHitBySession.set(sessionId, true)
-          }
+          if (event.status === "completed") discoveryHitByRequest.set(sessionId, true)
         } catch {}
       }
       // Track Engram hit (mem_search / mem_context / dedup) para soft gate 1.6
-      if (tool.includes("engram_mem_search") || tool.includes("engram_mem_context") || tool.includes("mem_search") || tool.includes("mem_context") || tool.includes("getEngramDedup") || tool.includes("engram_mem_")) {
+      if (tool.includes("engram_mem_search") || tool.includes("engram_mem_context") || tool.includes("mem_search") || tool.includes("mem_context") || tool.includes("engram_mem_")) {
         engramHitBySession.set(sessionId, true)
       }
+      // test-verification-execution: evidencia para tasks `test:`.
+      // `status` miente con exit != 0 (ver shellEvidence): sólo se registra con exit numérico.
+      // D10 respectado: NO cada shell persiste (git/ls/builds no tienen valor de evidencia y
+      // cada persist cuesta lock + re-read + write + 3 renames de backup). Se persisten sólo
+      // las corridas cuyo comando matchea un `test:` declarado en taskVerifications — que son
+      // las ÚNICAS que complete_task / verifyIntegrity consultan via findTestEvidence.
+      // Tradeoff fail-closed: si taskVerifications aún no llegó al state cuando se corre el
+      // test, la evidencia no se registra → complete_task pide re-correr (razón explícita).
+      try {
+        const ev = shellEvidence(event as any)
+        // Un shell que escribe (exit 0) también invalida evidencia de test:
+        // si no, `sed -i` mutaría el código sin avanzar el timestamp.
+        const mutating =
+          (isMutatingTool(tool) && event.status === "completed") ||
+          (!!ev && ev.exit === 0 && isShellMutation(ev.cmd))
+        const isTestRun = !!ev && testVerifyCommands(readState(directory)).has(ev.cmd)
+        if (isTestRun || mutating) {
+          const s = readState(directory)
+          if (s) {
+            const owned: string[] = []
+            if (ev && isTestRun) {
+              const prev = Array.isArray((s as any).shellRuns) ? (s as any).shellRuns : []
+              ;(s as any).shellRuns = [...prev, ev].slice(-25)
+              owned.push("shellRuns")
+            }
+            if (mutating) {
+              ;(s as any).lastMutationTs = Date.now()
+              owned.push("lastMutationTs")
+            }
+            if (owned.length > 0) persistState(directory, s, owned)
+          }
+        }
+      } catch {}
       // Heartbeat: single-writer — plugin memo, no persist cada tool (D10)
       try {
         const s = readState(directory)

package/assets/skills/brainstorming/SKILL.md

@@ -36,12 +36,12 @@ Do NOT invoke any implementation skill, write any code, or scaffold any project
 
 ### Process
 
-1. **Check discovery-cache first** — `src/discovery-cache.ts` `getDiscoverySnapshot(query)` + `getEngramDedup(query, requestId)`. Si hit válido (TTL+gitDiffHash), **reusar** sin llamar tools. Solo si miss → `engram_mem_search` + `codegraph_codegraph_explore` y **SHALL `putDiscoverySnapshot`** antes de avanzar. No re-llamar si área difiere <30% del snapshot.
+1. **Reusar discovery** — si ya llamaste `codegraph_codegraph_explore` para el área en este request, reusá ese output; si no, `engram_mem_search` + `codegraph_codegraph_explore`. No repitas la misma query sin motivo. No hay cache de archivo.
 2. **Ask clarifying questions** — one at a time, understand purpose/constraints/success criteria
 4. **Propose 2-3 approaches (hardening-v2 — SHALL)** — con tabla trade-offs (coste|riesgo|complejidad) + evidencia CodeGraph+Engram sin alucinar, YAGNI, y recomendación con razón; cada approach cita symbols existentes y mem_search hits verificables
 5. **Present design** — in sections scaled to complexity, get user approval after each section. **Gate post-brainstorming (hardening-v2):** tras presentar diseño, preguntar "¿Procedo con este diseño o querés ajustar algo?" y esperar confirmación explícita antes de `record_discovery`, `openspec-propose` o implementación directa
 6. **Write design doc (output path condicional — router exclusivo) — SHALL read fresco + edit no write + sync proactiva:**
-   - Antes de `write` SHALL `read` fresco de `openspec/changes/<id>/{proposal,design,tasks}` o `docs/superpowers/specs/*.md` si existen; si existen SHALL `edit` (no `write`); `write` solo si no existía. `getDiscoverySnapshot` no aplica a specs/docs. Para `open-explore` sin archivo SHALL `mem_save topic_key:brainstorm/<hash>` por iteración.
+   - Antes de `write` SHALL `read` fresco de `openspec/changes/<id>/{proposal,design,tasks}` o `docs/superpowers/specs/*.md` si existen; si existen SHALL `edit` (no `write`); `write` solo si no existía. El discovery no aplica a specs/docs. Para `open-explore` sin archivo SHALL `mem_save topic_key:brainstorm/<hash>` por iteración.
    - Si trigger + `level 1+` no-downgradeable (`estLines>30` o `fileCount>2` o API pública) y change activo → escribir `openspec/changes/<id>/design.md` sección `## Alternatives Considered` con 2-3 approaches (tabla coste|riesgo|complejidad + evidencia CodeGraph+Engram), no `docs/`. No invocar `openspec-propose` separado — este es el diseño. Si ya existe, SHALL `edit` no `write`.
    - Si trigger + `0/0+1` o `1+` downgradeable (`estLines<30`&&`fileCount==1`&&sin API) → solo `docs/superpowers/specs/YYYY-MM-DD-<topic>-design.md` + gate único `¿Procedo?` → DIRECT sin change. SHALL sugerir downgrade: `"Esto parece 0+1 (~X líneas, 1 archivo). ¿Lo tratamos sin spec?"` y esperar. Si `docsSpec` ya existe SHALL `read` + `edit`.
    - Gate post-brainstorming es **único**; no hay segundo `¿Procedo con spec?`. `get_audit` `WARN:duplicate_design_generated` si ambos artefactos mismo `requestId`.

package/assets/skills/execution-mode-evaluation/SKILL.md

@@ -25,14 +25,13 @@ Determinar el modo de ejecución óptimo entre **inline** y **subagent-driven**
 
 ## Procedimiento
 
-### Paso 0: Verificar discovery-cache primero (ÚNICO entrypoint)
-
-**SHALL** llamar `src/discovery-cache.ts` `getDiscoverySnapshot(query)` y `getEngramDedup(query, requestId)` antes de cualquier `codegraph_codegraph_explore` o `engram_mem_search`. Si hit válido (TTL+gitDiffHash) → **reusar** `codegraph+engramHits` para construir `sharedFiles/fileClusters`; solo `codegraph_impact` para símbolos no cubiertos. Si miss o área difiere >30% → fetch fresco y `putDiscoverySnapshot`. Segunda llamada misma query en mismo `requestId` SHALL ser dedup (no `redundantCallCount`).
-
-### Paso 0.1: Consultar Engram por decisiones previas (solo si no hay dedup hit)
-
-Si `getEngramDedup` fue miss, `engram_mem_search` con keywords del cambio. Si existe decisión previa, usar como referencia no vinculante.
-
+### Paso 0: Reusar el discovery ya obtenido en este request
+
+Si en este mismo request ya llamaste `codegraph_codegraph_explore` para el área, **reusá ese output** (sigue en tu contexto) para construir `sharedFiles/fileClusters`; solo `codegraph_impact` para símbolos no cubiertos. Si el área difiere materialmente (overlap <30%) o todavía no hiciste discovery → `codegraph_codegraph_explore` fresco. No hay cache de archivo: no repitas la misma query sin motivo.
+
+### Paso 0.1: Consultar Engram por decisiones previas
+
+`engram_mem_search` con keywords del cambio, salvo que ya lo hayas hecho para el mismo tema en este request. Si existe decisión previa, usarla como referencia no vinculante.
 ### Paso 0.5: Early exit para cambios pequeños
 
 Si el change tiene **≤2 tasks** Y **no comparten archivos entre sí** → devolver directamente:
@@ -48,10 +47,10 @@ Si el change tiene **≤2 tasks** Y **no comparten archivos entre sí** → devo
 }
 ```
 
-### Paso 1: Obtener datos de CodeGraph (solo si discovery-cache miss)
-
-Si Paso 0 fue hit → **SKIP este paso**, derivar `fileClusters/sharedFiles` del snapshot (`state.snapshots.codegraph` + `tasks.md`). Snapshot resultante SHALL usar `codegraphUsed:["discovery-cache"]` (válido, no genera `WARN:execution_without_codegraph` si `snapshots.codegraph` existe) y `reuseDiscovery:true`.
-Si miss:
+### Paso 1: Obtener datos de CodeGraph (solo si no hiciste discovery en este request)
+
+Si ya hay discovery en contexto → **SKIP este paso**; derivar `fileClusters/sharedFiles` del output (`state.snapshots.codegraph` + `tasks.md`) con `codegraphUsed:["codegraph_explore"]` y `reuseDiscovery:true`.
+Si no:
 ```
 codegraph_codegraph_explore con query: "<área del cambio>"
 ```

package/assets/skills/openspec-propose/SKILL.md

@@ -26,9 +26,9 @@ When ready to implement, run /opsx-apply
 
 **Steps**
 
-0. **Ground with CodeGraph + Engram (SHALL — Ostacky)** — Antes de `openspec new`, verifica `getDiscoverySnapshot(query)` + `getEngramDedup`. Si miss → `codegraph_codegraph_explore` + `engram_mem_search` + `putDiscoverySnapshot`. Cita símbolos existentes en `proposal/design`; sin esto el `design.md` puede alucinar API inexistente y dispara `WARN:codegraphBypass` en `doctor`.
+0. **Ground with CodeGraph + Engram (SHALL — Ostacky)** — Antes de `openspec new`, usá `codegraph_codegraph_explore` + `engram_mem_search` sobre el área (si no los hiciste ya en este request). Citá símbolos existentes en `proposal/design`; sin esto el `design.md` puede alucinar API inexistente y dispara `WARN:codegraphBypass` en `doctor`.
 
-1. **Check Engram for similar changes** — `engram_mem_search` con keywords del *paso 0* (reusar si ya fue hit; no duplicar `mem_search` mismo `requestId`). Si hay change similar previo, surfacealo. Pueden extender trabajo existente en vez de empezar de cero.
+1. **Check Engram for similar changes** — `engram_mem_search` con keywords del *paso 0* (no repetir la misma query en el mismo request). Si hay change similar previo, surfacealo. Pueden extender trabajo existente en vez de empezar de cero.
 
 2. **If no clear input provided, ask what they want to build**
 

package/assets/skills/tdd/SKILL.md

@@ -28,7 +28,7 @@ Write the test first. Watch it fail. Write minimal code to pass.
 
 Thinking "skip TDD just this once"? Stop. That's rationalization.
 
-> **Ostacky ground (SHALL):** Antes de RED, verifica `getDiscoverySnapshot(query)` + `getEngramDedup`. Si hit → reusar símbolos/decisiones; si miss → `codegraph_codegraph_explore` + `engram_mem_search` + `putDiscoverySnapshot`. Evita testear API inexistente y respeta `discovery-cache (único)` de `ostacky.md §1`. Ver `execution-mode-evaluation` para cache TTL.
+> **Ostacky ground (SHALL):** Antes de RED, verificá el área con `codegraph_codegraph_explore` + `engram_mem_search` (si no los hiciste ya en este request). Citá símbolos existentes para no testear API inexistente. Ver `execution-mode-evaluation`.
 
 ## The Iron Law