ostacky 0.7.1 → 0.7.3

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

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

package/assets/plugins/engram.ts

@@ -15,12 +15,26 @@
  */
 
 import type { Plugin } from "@opencode-ai/plugin"
+import { join, dirname, basename } from "path"
+import { readFileSync, writeFileSync, renameSync, mkdirSync } from "fs"
 
 // ─── Configuration ───────────────────────────────────────────────────────────
 
 const ENGRAM_PORT = parseInt(process.env.ENGRAM_PORT ?? "7437")
 const ENGRAM_URL = `http://127.0.0.1:${ENGRAM_PORT}`
-const ENGRAM_BIN = process.env.ENGRAM_BIN ?? Bun.which("engram") ?? ".opencode/tools/engram/bin/engram"
+// C3/H2 fix: resolve ENGRAM_BIN per ctx.directory with win32 .exe and absolute fallback
+function resolveEngramBin(directory: string): string {
+  if (process.env.ENGRAM_BIN) {
+    const p = process.env.ENGRAM_BIN
+    const isAbs = p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p)
+    return isAbs ? p : join(directory, p)
+  }
+  const which = Bun.which("engram")
+  if (which) return which
+  const suffix = process.platform === "win32" ? ".exe" : ""
+  return join(directory, ".opencode", "tools", "engram", "bin", `engram${suffix}`)
+}
+// ENGRAM_BIN eliminado: reemplazado por resolveEngramBin(ctx.directory) que maneja .exe+absolutización correctamente
 
 // Engram's own MCP tools — don't count these as "tool calls" for session stats
 const ENGRAM_TOOLS = new Set([
@@ -171,12 +185,12 @@ function extractProjectName(directory: string): string {
     const result = Bun.spawnSync(["git", "-C", directory, "rev-parse", "--show-toplevel"])
     if (result.exitCode === 0) {
       const root = result.stdout?.toString().trim()
-      if (root) return root.split("/").pop() ?? "unknown"
+      if (root) return basename(root.replace(/\\/g, "/")) ?? "unknown"
     }
   } catch {}
 
-  // Final fallback: cwd basename
-  return directory.split("/").pop() ?? "unknown"
+  // Final fallback: cwd basename (cross-platform)
+  return basename(directory.replace(/\\/g, "/")) ?? "unknown"
 }
 
 function truncate(str: string, max: number): string {
@@ -194,10 +208,51 @@ 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) => {
-  const oldProject = ctx.directory.split("/").pop() ?? "unknown"
+  // T4: basename multiplataforma — split("/") producía keys basura con backslashes en Windows nativo
+  const oldProject = basename(ctx.directory.replace(/\\/g, "/")) ?? "unknown"
   const project = extractProjectName(ctx.directory)
 
   // Track tool counts per session (in-memory only, not critical)
@@ -236,11 +291,12 @@ export const Engram: Plugin = async (ctx) => {
     })
   }
 
-  // Try to start engram server if not running
+  // Try to start engram server if not running — use per-directory resolved bin (win32 .exe + absolute)
+  const engramBin = resolveEngramBin(ctx.directory)
   const running = await isEngramRunning()
   if (!running) {
     try {
-      Bun.spawn([ENGRAM_BIN, "serve"], {
+      Bun.spawn([engramBin, "serve"], {
         stdout: "ignore",
         stderr: "ignore",
         stdin: "ignore",
@@ -268,7 +324,7 @@ export const Engram: Plugin = async (ctx) => {
     const manifestFile = `${ctx.directory}/.engram/manifest.json`
     const file = Bun.file(manifestFile)
     if (await file.exists()) {
-      Bun.spawn([ENGRAM_BIN, "sync", "--import"], {
+      Bun.spawn([engramBin, "sync", "--import"], {
         cwd: ctx.directory,
         stdout: "ignore",
         stderr: "ignore",
@@ -513,6 +569,60 @@ export const Engram: Plugin = async (ctx) => {
         await ensureSession(input.sessionID)
       }
 
+      // C3: Compaction fallback file — write directly to same anchor as controller's get_handoff
+      // Resolves statePath from opencode.json (local) or global config, default .opencode/ostacky-state.json
+      try {
+        let statePath: string | null = null
+        // 1) env var if set
+        if (process.env.OSTACKY_STATE_PATH) {
+          statePath = process.env.OSTACKY_STATE_PATH
+        }
+        // 2) try local opencode.json / jsonc in project
+        if (!statePath) {
+          const candidates = [join(ctx.directory, "opencode.json"), join(ctx.directory, "opencode.jsonc")]
+          // also try global config (XDG / APPDATA)
+          try {
+            const home = process.env.HOME ?? process.env.USERPROFILE ?? ""
+            if (home) {
+              const xdg = process.env.XDG_CONFIG_HOME ?? join(home, ".config")
+              candidates.push(join(xdg, "opencode", "opencode.json"))
+              candidates.push(join(xdg, "opencode", "opencode.jsonc"))
+              if (process.platform === "win32" && process.env.APPDATA) {
+                candidates.push(join(process.env.APPDATA, "opencode", "opencode.json"))
+                candidates.push(join(process.env.APPDATA, "opencode", "opencode.jsonc"))
+              }
+            }
+          } catch {}
+          for (const cand of candidates) {
+            try {
+              const raw = readFileSync(cand, "utf-8")
+              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) {
+                statePath = envPath
+                break
+              }
+            } catch {}
+          }
+        }
+        if (!statePath) statePath = join(ctx.directory, ".opencode", "ostacky-state.json")
+        const fallbackPath = join(dirname(statePath), ".ostacky-handoff-compaction.json")
+        try { mkdirSync(dirname(fallbackPath), { recursive: true }) } catch {}
+        const payload = {
+          summary: `Compaction fallback for session ${input.sessionID ?? "unknown"} — project ${project}`,
+          nextSteps: [] as string[],
+          pendingTasks: [] as string[],
+          ts: Date.now(),
+          contextSnippet: output.context?.slice(0, 2).join("\n\n").slice(0, 1000) ?? "",
+        }
+        const tmp = `${fallbackPath}.tmp.${process.pid}`
+        writeFileSync(tmp, JSON.stringify(payload, null, 2), "utf-8")
+        renameSync(tmp, fallbackPath)
+      } catch {
+        // fallback is best-effort — never crash compacting
+      }
+
       // Inject context from previous sessions
       const data = await engramFetch(
         `/context?project=${encodeURIComponent(project)}`

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

@@ -157,6 +157,10 @@ Modo básico: sin validación de edits, sin memoria persistente, sin análisis e
 ¿Continuar o cancelar?
 ```
 
+## Handoff Fallback (compaction)
+
+Si el controller hizo `set_handoff` o el plugin escribió el fallback `dirname(OSTACKY_STATE_PATH)/.ostacky-handoff-compaction.json` antes de compaction, el próximo agente **debe** llamar `get_handoff` al inicio. `get_handoff` primero chequea `lastHandoff` en memoria y si es `null` lee el archivo fallback (mismo ancla que el writer). `clear_handoff` borra ambos. `cleanupTmpFiles` solo borra ese archivo si `ts >24h`. Ver `assets/plugins/engram.ts:experimental.session.compacting` y `assets/mcp/ostacky-controller/index.js:get_handoff`.
+
 ## Recovery After Degradation
 
 When a tool becomes available again during the session:
@@ -166,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:**