ostacky 0.7.2 → 0.7.3

package/assets/mcp/ostacky-controller/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ostacky-controller",
-    "version": "0.7.2",
+    "version": "0.7.3",
     "private": true,
     "type": "module",
     "dependencies": {

package/assets/plugins/engram.ts

@@ -208,6 +208,46 @@ function stripPrivateTags(str: string): string {
   return str.replace(/<private>[\s\S]*?<\/private>/gi, "[REDACTED]").trim()
 }
 
+function stripJsoncComments(text: string): string {
+  let result = ""
+  let i = 0
+  let inString = false
+  while (i < text.length) {
+    const char = text[i]
+    const next = text[i + 1]
+    if (inString) {
+      if (char === "\\") {
+        result += char + (next ?? "")
+        i += 2
+        continue
+      }
+      if (char === '"') inString = false
+      result += char
+      i++
+      continue
+    }
+    if (char === '"') {
+      inString = true
+      result += char
+      i++
+      continue
+    }
+    if (char === "/" && next === "/") {
+      while (i < text.length && text[i] !== "\n") i++
+      continue
+    }
+    if (char === "/" && next === "*") {
+      i += 2
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++
+      i += 2
+      continue
+    }
+    result += char
+    i++
+  }
+  return result.replace(/,\s*([}\]])/g, "$1")
+}
+
 // ─── Plugin Export ───────────────────────────────────────────────────────────
 
 export const Engram: Plugin = async (ctx) => {
@@ -556,11 +596,7 @@ export const Engram: Plugin = async (ctx) => {
           for (const cand of candidates) {
             try {
               const raw = readFileSync(cand, "utf-8")
-              // strip // and /* */ comments for jsonc
-              let j = raw
-                .replace(/\/\/.*$/gm, "")
-                .replace(/\/\*[\s\S]*?\*\//g, "")
-                .replace(/,\s*([}\]])/g, "$1")
+              const j = stripJsoncComments(raw)
               const cfg = JSON.parse(j)
               const envPath = (cfg as any)?.mcp?.["ostacky-controller"]?.environment?.OSTACKY_STATE_PATH
               if (typeof envPath === "string" && envPath) {

package/assets/plugins/ostacky-guard.ts

@@ -0,0 +1,131 @@
+/**
+ * Ostacky Guard — plugin hermano de Engram
+ *
+ * Bloquea lecturas sensibles sin autorización previa y bloquea cualquier tool
+ * cuando el controller está en estado PENDING.
+ *
+ * Se registra en `tool.execute.before` y lanza Error si la operación no está
+ * permitida. OpenCode aborta el tool antes de tocar disco.
+ */
+
+import type { Plugin } from "@opencode-ai/plugin"
+import { readFileSync, existsSync } from "node:fs"
+import { join, dirname, basename, resolve, relative } from "node:path"
+
+const SENSITIVE_DEFAULT = [
+  "**/.env*",
+  "**/.secrets/**",
+  "**/*.pem",
+  "**/*.key",
+  "**/.aws/**",
+  "**/.ssh/**",
+  "**/credentials.json",
+  "**/.npmrc",
+]
+
+function getEnvPatterns(): string[] {
+  const raw = process.env.OSTACKY_SENSITIVE_PATTERNS
+  if (!raw) return SENSITIVE_DEFAULT
+  return raw.split(",").map((s) => s.trim()).filter(Boolean)
+}
+
+function isSensitive(filePath: string, patterns: string[]): boolean {
+  if (!filePath) return false
+  const lower = filePath.toLowerCase()
+  if (lower.endsWith(".env.example") || lower.endsWith(".env.template") || lower.endsWith(".env.sample")) return false
+  for (const pat of patterns) {
+    if (pat.includes(".env") && lower.split("/").pop()!.startsWith(".env")) return true
+    if (pat.includes(".secrets") && lower.includes(".secrets")) return true
+    if (pat.includes("*.pem") && lower.endsWith(".pem")) return true
+    if (pat.includes("*.key") && lower.endsWith(".key")) return true
+    if (pat.includes(".aws") && lower.includes(".aws")) return true
+    if (pat.includes(".ssh") && lower.includes(".ssh")) return true
+    if (pat.includes("credentials.json") && lower.endsWith("credentials.json")) return true
+    if (pat.includes(".npmrc") && lower.endsWith(".npmrc")) return true
+  }
+  if (/\.(pem|key)$/i.test(filePath)) return true
+  if (filePath.includes(".env")) {
+    const base = filePath.split("/").pop() || ""
+    if (base.startsWith(".env")) return true
+  }
+  return false
+}
+
+function getStatePath(directory: string): string {
+  if (process.env.OSTACKY_STATE_PATH) return process.env.OSTACKY_STATE_PATH
+  // try opencode.json
+  const candidates = [join(directory, "opencode.json"), join(directory, "opencode.jsonc")]
+  for (const cand of candidates) {
+    try {
+      const raw = readFileSync(cand, "utf-8")
+      // naive parse, ignore comments
+      const json = JSON.parse(raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, ""))
+      const envPath = (json as any)?.mcp?.["ostacky-controller"]?.environment?.OSTACKY_STATE_PATH
+      if (typeof envPath === "string" && envPath) return envPath
+    } catch {}
+  }
+  return join(directory, ".opencode", "ostacky-state.json")
+}
+
+function readState(directory: string): any | null {
+  const p = getStatePath(directory)
+  try {
+    const raw = readFileSync(p, "utf-8")
+    return JSON.parse(raw)
+  } catch {
+    return null
+  }
+}
+
+export const OstackyGuard: Plugin = async (ctx) => {
+  const patterns = getEnvPatterns()
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      const tool = (input as any).tool as string
+      const args = (input as any).args as any
+
+      // Extraer filePath de args según tool
+      let filePath: string | undefined
+      if (tool === "read" || tool === "read_mcp_resource" || tool === "grep" || tool === "glob") {
+        filePath = args?.filePath || args?.path || args?.pattern || args?.uri || ""
+        // Para grep, el pattern puede ser contenido, no file; intentar detectar file
+        if (tool === "grep" && args?.include) filePath = args.include
+        if (tool === "read_mcp_resource" && typeof args?.uri === "string") {
+          // uri puede ser file:// o path
+          try {
+            const u = args.uri as string
+            if (u.startsWith("file://")) filePath = u.slice(7)
+            else if (u.includes("/") ) filePath = u
+          } catch {}
+        }
+      }
+
+      // 10.2: Guard genérico de PENDING — bloquear cualquier tool no-controller cuando estado es PENDING
+      const state = readState(ctx.directory)
+      const pendingStates = ["ROUTE_DECISION_PENDING", "EXECUTION_DECISION_PENDING", "CLARIFICATION_PENDING"]
+      if (state && pendingStates.includes(state.state)) {
+        // Permitir solo tools del controller que desbloquean
+        const allowedTools = ["consume_route_decision", "consume_execution_decision", "record_clarification", "abandon", "check_file_access", "consume_file_access_decision", "record_user_confirmation"]
+        const isControllerTool = tool.startsWith("ostacky-controller_") || allowedTools.some((t) => tool.includes(t))
+        if (!isControllerTool) {
+          // Bloquear cualquier tool no-controller (Read/Grep/Glob/Bash/Edit/Write) cuando está en PENDING — hard gate genérico
+          throw new Error(`BLOCKED: call consume_* first — controller is in ${state.state}. Use consume_route_decision / consume_execution_decision / record_clarification to proceed.`)
+        }
+      }
+
+      // 9.1: Guard de credenciales
+      if (filePath && isSensitive(filePath, patterns)) {
+        const s = readState(ctx.directory)
+        const allowed = s?.allowedFiles?.[filePath]
+        if (!allowed) {
+          const denied = s?.deniedFiles?.[filePath]
+          if (denied) {
+            throw new Error(`BLOCKED: File ${filePath} requires check_file_access (previously denied)`)
+          }
+          throw new Error(`BLOCKED: File ${filePath} requires check_file_access`)
+        }
+      }
+    },
+  }
+}

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

@@ -112,6 +112,7 @@ Para cada fase de `tasks.md`, evaluar intra-fase:
   "reasons": ["razón principal", "razón secundaria"],
   "codegraphUsed": ["codegraph_codegraph_explore"],
   "taskCount": <N>,
+  "expectedTaskIds": ["T1", "T2", "T3"],
   "sharedFiles": { "src/archivo.ts": ["task1", "task2"] },
   "fileClusters": [["task1", "task2"], ["task3"]],
   "clusterCount": <N>,
@@ -124,6 +125,9 @@ Para cada fase de `tasks.md`, evaluar intra-fase:
 }
 ```
 
+> **Nota 6.1:** `expectedTaskIds` es **obligatorio** cuando `taskCount>0` — el controller lo exige y rechaza snapshot sin él (excepto `early-exit` con `taskCount<=2` y `codegraphUsed:[]` que es válido sin WARN).
+> Ejemplo early-exit válido: `{"recommendation":"INLINE","reasons":["Cambio pequeño"],"codegraphUsed":[],"taskCount":2,"expectedTaskIds":["T1","T2"],"globalRuleTriggered":"early-exit"}`
+
 **Output para el usuario (mostrar en lenguaje natural):**
 
 ```markdown
@@ -167,6 +171,8 @@ Para cada fase de `tasks.md`, evaluar intra-fase:
 | `sequentialDeps` | Dependencias secuenciales entre tasks |
 | `estLines` | Estimación conservadora |
 | `hasExplicitContract` | `true` si design.md explicita contratos |
+| `expectedTaskIds` | **Obligatorio** cuando `taskCount>0` — gate del controller |
+| `taskCount` | Total tasks, debe coincidir con `expectedTaskIds.length` |
 
 **⚠️ Este skill provee ANÁLISIS, no autorización.** El coordinador muestra el snapshot al usuario y pide confirmación en lenguaje natural, luego espera la respuesta.
 
@@ -184,6 +190,8 @@ Para cada fase de `tasks.md`, evaluar intra-fase:
 - [ ] Verifiqué deps ENTRE clusters (no solo intra)?
 - [ ] Apliqué reglas en orden (1→2a/2b→3a/3b/3c)?
 - [ ] Anoté `globalRuleTriggered`?
+- [ ] Incluí `expectedTaskIds` (obligatorio cuando `taskCount>0`) y verifiqué que `taskCount == expectedTaskIds.length`?
 - [ ] Si global es inline, ejecuté Paso 3b por fase?
-- [ ] Si global es subagent por clusters (Rule 2b), documenté dispatch?
+- [ ] Si global es subagent por clusters (Rule 2b), documenté dispatch por clusters (máx 3 subagentes, advertir si `clusterCount>3` → oleadas)?
 - [ ] Output es JSON válido con todos los campos del contrato?
+- [ ] Early-exit con `codegraphUsed:[]` y `taskCount<=2` solo cuando realmente es cambio trivial (no genera WARN)?

package/assets/skills/graceful-degradation/SKILL.md

@@ -170,6 +170,15 @@ When a tool becomes available again during the session:
 3. **Resume:** Switch back to normal workflow
 4. **Catch up:** Use the tool to verify recent work
 
+## Health via get_metrics y doctor (6.2)
+
+- **Con Controller:** usar `get_metrics` como health — expone `degraded`, `diskFreeMB`, `auditSize`, `stateFileSize`, `codegraphBypassCount`, `stateOversizedCount`, `degradedEditsCount`, `sensitiveAccess`. Si `diskFreeMB<100` → ⚠️ Disco casi lleno; si `stateOversizedCount>0` → snapshots perdidos.
+- **Sin Controller:** fallback a `ostacky doctor` (lee `.opencode/ostacky-state.json` sin MCP, verifica locks, tamaños, audit, binarios y `manifest.json` hashes). `doctor` es el fallback a `check:skills` cuando MCP caído.
+- **Sin CodeGraph:** `get_metrics.codegraphBypassCount` incrementa cuando `record_discovery` sin `symbols` y no degraded; `get_audit` marca `inefficient: codegraph bypass` para review.
+- **Sin Engram:** continuar sin memoria; `doctor` no requiere Engram.
+
+No usar `skill("engram")` — Engram es MCP server, no skill. Usar `engram_mem_*` tools.
+
 ## Guardrails
 
 ### During Degradation

package/assets/skills/using-git-worktrees/SKILL.md

@@ -201,6 +201,14 @@ Ready to implement auth feature
 - Auto-detect and run project setup
 - Verify clean test baseline
 
+## Ostacky Worktree Isolation
+
+Cada worktree de git es **aislado** para Ostacky:
+
+- **State file independiente:** `findProjectRoot()` resuelve el root del worktree vía `git rev-parse --show-toplevel` (cada worktree tiene su propio `.opencode/ostacky-state.json`). Dos worktrees no comparten `statePath`, por lo que `ostacky-controller` no pisa estados entre worktrees.
+- **Lock independiente:** cada worktree tiene su propio `.lock` y `.backup` rotativo, por lo que 3 agentes en 3 worktrees no corrompen el lock del otro.
+- **Verificación:** `tests` con dos tmp dirs simulando worktrees verifican que no comparten `statePath` y que `doctor` reporta OK en cada uno.
+
 ## Integration
 
 **Called by:**