ostacky 0.10.1 → 0.10.3

package/README.md

@@ -61,6 +61,8 @@ Escribe el núcleo en el config dir global de OpenCode, sin tocar ningún proyec
 
 La config global acepta `opencode.json` o `opencode.jsonc`. Si el proyecto define el mismo MCP, el del proyecto reemplaza al global (comportamiento v2); en skills con mismo ID gana la del proyecto.
 
+El plugin del controller sigue la misma regla, pero necesita ayuda explícita: OpenCode V2 dedupea plugins por `id` y conserva la **primera** ocurrencia en orden de arranque, y el config global se descubre antes que el del proyecto. Con el mismo id, el global gana y el local queda `failed: "Duplicate plugin ID"`. Por eso la copia global declara `ostacky-controller-global` y su `setup` no registra nada si el proyecto tiene `.opencode/plugins/ostacky-controller/` — precedencia local, sin dobles hooks. El chequeo corre en `setup` (una vez por carga): si instalás el local con el global ya activo en la sesión, reiniciá OpenCode para que la copia global ceda.
+
 > **Migración v1 → v2:** `npx ostacky` sin subcomando busca la última versión publicada y, si detecta v1 instalada, ofrece migrar (siempre con confirmación).
 
 ### Por qué el stack es local
@@ -129,9 +131,9 @@ Local (`<proyecto>/.opencode`) o global (mismo árbol bajo el dir global, sin st
 
 ```json
 {
-    "version": "0.10.1",
-    "tag": "v0.10.1",
-    "agents": { "ostacky": { "version": "0.10.1", "sha256": "…" } },
+    "version": "0.10.3",
+    "tag": "v0.10.3",
+    "agents": { "ostacky": { "version": "0.10.3", "sha256": "…" } },
     "commands": { "install-stack": { … }, "opsx-sync": { … } },
     "skills": { "brainstorming": { … }, "…" : {} },
     "mcpServers": { "ostacky-controller": { … }, "openspec": { … } }

package/assets/agents/ostacky.md

@@ -1,17 +1,17 @@
 ---
 description: Orquestador principal — rutea por nivel, orquesta CodeGraph + OpenSpec + Superpowers.
 mode: primary
-version: 0.10.1
+version: 0.10.3
 ---
 
-Sos **Ostacky v0.10.1**, orquestás, no implementás. Interpretás, clasificás (0/0+1/1+), ruteás y coordinás.
+Sos **Ostacky v0.10.3**, orquestás, no implementás. Interpretás, clasificás (0/0+1/1+), ruteás y coordinás.
 
-> **Versión:** `0.10.1` (sincronizada desde `package.json` vía `scripts/sync-version.ts`). Cuando te pregunten qué versión tenés, qué versión sos, o `¿qué versión tenés?` / `version` / `¿en qué versión estás?`, respondé exactamente: **"Ostacky v0.10.1"** (o `v0.10.1` si te piden solo el número). No inventes otra versión.
+> **Versión:** `0.10.3` (sincronizada desde `package.json` vía `scripts/sync-version.ts`). Cuando te pregunten qué versión tenés, qué versión sos, o `¿qué versión tenés?` / `version` / `¿en qué versión estás?`, respondé exactamente: **"Ostacky v0.10.3"** (o `v0.10.3` si te piden solo el número). No inventes otra versión.
 
 ## Reglas innegociables
 
 1. **NUNCA te congeles.** Plan B antes de tool, no reintentes fallida.
-2. **CodeGraph primero.** Nunca `rg/grep` para código. `Grep` solo literales.
+2. **CodeGraph primero ante query de símbolo/flujo/impacto** (¿quién llama a X?, blast radius, dónde vive un símbolo). Grep/glob directo es legítimo ante query de literal (string exacto, TODO, config, `.md`/`.json`) — pero el gate SIEMPRE exige un `codegraph_codegraph_explore` completado antes de leer código (`shouldBlockCodeRead`). Para leer código no-indexable a conciencia, el explore previo es calibración, no sobrehead: barato, local y confirma que el índice está vivo.
 3. **El plugin hace cumplir PENDING.** Hard gate en `ctx.tool.hook("execute.before")`; no llames `check_*` manual.
 4. **No edites sin Read fresco.** Nunca cache de turno anterior.
 5. **Una pregunta por turno.** Natural, sin tool, STOP y esperar. Respuesta vinculante.
@@ -73,6 +73,8 @@ Si vago → preguntar. Si claro → `start_request`.
 
 **Nivel 0 → DIRECT automático (sin pregunta de ruteo):** anunciar `Nivel 0 + archivos + qué se va a hacer` y proceder con `consume_route_decision(DIRECT)`; el veto del usuario vale (si objeta, se frena). Niveles `0+1`/`1+` → preguntar nivel y `consume_route_decision` (una pregunta por turno).
 
+**DIRECT sobre 1+ (override):** si el usuario elige DIRECT en un run 1+ sin `tasks.md`, SHALL registrar el plan inline con `set_expected_tasks({taskIds:[...]})` (3-7 pasos con sus archivos) antes de la primera edición y usarlo como checklist; sin plan NO SHALL editar.
+
 ### 3. Specification (solo SPEC)
 
 Router `brainstorming`↔`OpenSpec` por `level`/`estLines`/`fileCount`/`hasAPI` (no keywords). `1+` no-downgradeable → `skill(brainstorming)` genera `design.md ## Alternatives`; downgradeable → `docs/...` + `DIRECT`.
@@ -85,18 +87,25 @@ Router `brainstorming`↔`OpenSpec` por `level`/`estLines`/`fileCount`/`hasAPI`
 ### 4. Execution
 
 1. `skill(execution-mode-evaluation)` en memoria, reusa discovery.
-2. Gate ÚNICO (sin segunda pregunta): presentar resumen único `Nivel + DIRECT/SPEC + INLINE/SUBAGENT + archivos + ~líneas` (+ comparativa tokens|tiempo si `1+` multi-archivo) → UNA sola pregunta `¿Procedo?` (el usuario puede modificar). Si hay Riesgo concreto verificable aunque sea 0+1, el resumen incluye `Riesgo concreto: … → Mitigación: …`; sin riesgo verificable no se inventa ninguno. Todo override a advertencia del agente (de memoria o técnica) SHALL pasar por `record_user_confirmation`. Si confirma → `record_execution_analysis` + `consume_execution_decision` seguidos sin volver a preguntar. `Nivel 0` y mismo-archivo → recomendación fija `INLINE/DIRECT` sin alternativa. `1+` multi-archivo → tabla `INLINE (1x contexto, más lento) vs SUBAGENT (Nx contexto, más rápido, reglas 2b/3c intactas)` + recomendación; nunca forzar `INLINE`.
+2. Gate ÚNICO (sin segunda pregunta): presentar resumen único `Nivel + DIRECT/SPEC + INLINE/SUBAGENT + archivos + ~líneas` (+ comparativa tokens|tiempo si `1+` multi-archivo) → UNA sola pregunta `¿Procedo?` (el usuario puede modificar). Si hay riesgo verificable aunque sea 0+1, el resumen incluye `Riesgo: <qué se rompe en llano> · Evidencia: <ruta relativa al proyecto>:<línea> · Mitigación: <acción>`; sin evidencia verificable NO SHALL inventarse. Todo override a advertencia SHALL pasar por `record_user_confirmation`, pero si la respuesta de ruta ya fue explícita («ejecutar DIRECT»), esa respuesta ES el override: se registra y NO se re-pregunta — el turno siguiente es este gate. Si confirma → `record_execution_analysis` + `consume_execution_decision` seguidos sin volver a preguntar. `Nivel 0` y mismo-archivo → recomendación fija `INLINE/DIRECT` sin alternativa. `1+` multi-archivo → tabla `INLINE (1x contexto, más lento) vs SUBAGENT (Nx contexto, más rápido, reglas 2b/3c intactas)` + recomendación; nunca forzar `INLINE`.
 3. Por task: `Read` fresco → plugin valida edición in-process → `edit` → `complete_task`. El chequeo corre dentro de complete_task (no existe la tool `verify_task`): elige la verificación de `— verificar:` en `tasks.md` y devuelve el motivo si falla. **NUNCA marques `complete_task` a ojo**; si la verificación falla, reintentá el fix. Vale para SPEC y DIRECT, INLINE y SUBAGENTS.
 
+   **Progreso visible:** si `expectedTasks.length > 1`, después de cada `complete_task` SHALL reportar `✅ Tn/N — <archivo>` + `quedan: T…` (máx. 2 líneas) sin esperar a que el usuario pregunte; al cerrar la última task de una fase de `tasks.md`, SHALL resumir lo hecho, listar lo pendiente de las fases siguientes y proponer continuar en UNA pregunta. Con una sola task NO SHALL emitir el bloque.
+
+   **`complete_task` con archivo:** en tasks con verificación `file:`, SHALL llamar `complete_task({taskId, filePath})`; el cierre re-verifica el needle contra ESE archivo y sin `filePath` no puede hacerlo. El validate del plugin es por archivo y se consume con cada `complete_task`: dos tasks sobre el mismo archivo necesitan una edición entre medio.
+
 ### 5. Sync y cierre
 
 1. Tests + review
 2. `saveSessionClose` → `mem_session_summary` + `set_handoff` paralelo
 3. `verifyIntegrity` → **si `pending.length > 0` NO llames `implementation_complete`**; lista explícita `Te faltan N tasks: [...]` y pide `complete_task`. Si `staleFiles.length > 0` por refino post-complete (archivo ya correcto, sin edición pendiente): llamá `refresh_fingerprint({filePath})` por cada archivo y reintentá `implementation_complete` sin `force`. Solo si `pending === 0` y `staleFiles === 0`, `implementation_complete` → `sync_complete`. **NUNCA llames `implementation_complete` automáticamente con pendientes** — espera a que el usuario complete o escriba literal `"confirmo forzar"` para `force:true` (queda auditado). Vale para SPEC y DIRECT, INLINE y SUBAGENTS.
 
+   Si `verificationFailed` no está vacío, revisá que cada task con `file:` haya declarado `filePath` en su `complete_task`: el re-chequeo del cierre lee ese archivo, no el path escrito en la verificación.
+
 ## Guardrails
 
 - Decisión en OpenSpec/CodeGraph/controller → no re-resolver
+- **Multi-sesión (un state file por proyecto):** si `start_request` devuelve `conflict:true` o un tool devuelve `BLOCKED: … pertenece a otra sesión`, NO re-presentes el resumen de ejecución ni consumas/bloquees esa decisión. Preguntá una sola cosa: takeover explícito (`start_request({force:true})`, auditado) o continuar en la otra sesión. Si `get_state` muestra `callerSessionId:null` con `ownerSessionId` no nulo, tratá la request como ajena (no hay identidad que pruebe lo contrario).
 - Una pregunta por turno, sin deadlock
 - Fase gate: en EXECUTING/SYNC no volver a DISCOVERY
 - Audit: log antes de gate + `mem_save` solo en gates

package/assets/commands/install-stack.md

@@ -6,7 +6,7 @@ subagent: false
 
 Instala el stack tecnológico de desarrollo para OpenCode. **IMPORTANTE:** las herramientas se instalan por separado (cada una con su propio CLI/comando). `npx ostacky install` solo instala el agente y commands de Ostacky en `.opencode/`. Este comando (`/install-stack`) es la guía de referencia para la instalación manual completa paso a paso.
 
-**Nota:** A partir de v0.10.1, `npx ostacky install` ya instala automáticamente el stack completo (CodeGraph, OpenSpec, Engram, MCPs bundleados) además del agente y skills. Este comando es útil para instalación manual, verificación, o cuando algo falló y necesita reinstalarse.
+**Nota:** A partir de v0.10.3, `npx ostacky install` ya instala automáticamente el stack completo (CodeGraph, OpenSpec, Engram, MCPs bundleados) además del agente y skills. Este comando es útil para instalación manual, verificación, o cuando algo falló y necesita reinstalarse.
 
 **RESTRICCIÓN ABSOLUTA:** instalar ÚNICAMENTE para OpenCode. Está terminantemente prohibido crear o modificar archivos en `.claude/`, `.kiro/`, `.cursor/`, `.gemini/`, `.codex/`, `.antigravity/`, `.windsurf/` o cualquier otro directorio de plataformas externas.
 

package/assets/docs/ostacky-reference.md

@@ -105,6 +105,14 @@ Principio: **eficacia > recorte** — si recorte rompiera caché y saliera más
 
 `src/controller-core.ts` CANÓNICO para `STATES/TRANSITIONS/DEFAULT_STATE`; mirrors generados en `assets/plugins/ostacky-controller/controller-core.ts` (TS) y `assets/mcp/ostacky-controller/controller-core.js` (JS strippado) vía `bun run scripts/sync-controller-core.ts` (prebuild). No editar mirrors. `index.ts` importa de `./controller-core.ts` self-contained. Import siempre `./security.ts` (el server V2 no resuelve `.js→.ts`).
 
+## Release — MCP bundles (`dist/mcp`)
+
+`bun run build:mcp` compila cada `mcpServers[]` del manifest a `dist/mcp/<name>/index.js` autocontenido (sin `node_modules` al lado). `installMcpServer` prefiere ese artefacto; si no existe cae al fallback dev (copiar `assets/mcp/<name>/` + `bun install`/`npm install` en la máquina del usuario).
+
+- `manifest.json`: `mcpServers[].sha256` = hash del **artefacto** que se copia (bundle si existe, si no el tree hash del source); `sourceSha256` = tree hash de `assets/mcp/<name>/` siempre. `assertBundledTreeHash(category, name, hash, field)` valida el campo que corresponde al camino elegido.
+- `bun run hash:update` (build:mcp + hashes) es el camino para actualizar el manifest; `hash:check` corre en CI después del build.
+- CI pinnea `bun-version` (1.4.2): el hash del bundle depende del output de bun.
+
 ## Prompt-efficiency
 
 - `ostacky.md` 109→72 líneas (diet estable cacheable). Tiered vía suffix, no reemplazo `system[0]`.
@@ -114,3 +122,11 @@ Principio: **eficacia > recorte** — si recorte rompiera caché y saliera más
 ## Propose Flow (1+)
 
 `openspec-propose` SHALL Paso 0: `codegraph_codegraph_explore` + `engram_mem_search` sobre el área (si no se hicieron ya en el request) **antes** de `openspec new`. Citá símbolos existentes en `proposal/design`; sin esto dispara `WARN:codegraphBypass` y `design.md` alucina API. Ver `assets/skills/openspec-propose/SKILL.md: Paso 0` y `brainstorming` (router por nivel: `brainstorming` decide 0/0+1/1+, `openspec-explore` es stance sin nivel).
+
+## CI — openspec validate (remediación)
+
+El job `test` de `.github/workflows/ci.yml` corre `bunx openspec validate --all --strict` (dep pinneada en `package.json`). Si falla en `main`: un delta/spec inválido entró — NO archivearlo roto ni hacer workaround. Protocolo:
+1. El output lista el item roto (`✗ change/<id>` / `✗ spec/<name>`) + `Details: openspec validate <id> --type change|spec` — ese comando da la causa exacta y los next steps (el CLI es autoexplicativo: headers `## ADDED/MODIFIED/REMOVED/RENAMED Requirements`, cada requirement con al menos un `#### Scenario:`).
+2. Debug de deltas parseados: `openspec show <id> --json --deltas-only`.
+3. Change WIP incompleto en `main` → completarlo o removerlo del repo; specs de `openspec/specs/` rotos → fixear el formato in-place.
+4. Si tocás `assets/` regenerá hashes (`bun run hash:update`) y usá `bun run test:safe` (nunca `bun test` full: se cuelga).

package/assets/mcp/ostacky-controller/index.js

@@ -49,6 +49,11 @@ import {
 // y al umbral habilita recovery (refresh_decision) sin ejecutar nada por sí mismo.
 const CONSUME_FAIL_THRESHOLD = 3;
 
+// Ownership con heartbeat: un dueño sin latido por más de esto se considera
+// muerto (TUI cerrada, proceso kill) y la sesión nueva puede reclamar la
+// request sin pedirle takeover al usuario. 15 min cubre tools largas.
+const OWNER_STALE_MS = 15 * 60 * 1000;
+
 // --- Audit JSONL (D5) — single source: src/audit-jsonl.ts ---
 function getAuditPath(projectRoot) {
     return join(projectRoot, '.opencode', 'ostacky-audit.jsonl');
@@ -120,6 +125,39 @@ function readAuditJsonl(projectRoot, opts = {}) {
 // T1: non-blocking wait — replaces busy-wait spins that froze the event loop
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
+function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+/** Pid dueño del lock, o null si el archivo no existe / está corrupto. */
+function readLockPid(pidPath) {
+    try {
+        const pid = parseInt(readFileSync(pidPath, 'utf8').trim(), 10);
+        return Number.isNaN(pid) ? null : pid;
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Antigüedad del archivo de pid. Un lock sin timestamp recién escrito es una
+ * adquisición en curso (el dueño escribe el timestamp inmediatamente después);
+ * si ya pasó el grace, es basura de un crash.
+ */
+function lockPidAgeMs(pidPath) {
+    try {
+        return Date.now() - statSync(pidPath).mtimeMs;
+    } catch {
+        return Number.POSITIVE_INFINITY;
+    }
+}
+
 function getProjectRoot(statePath) {
     if (!statePath) return resolve(process.cwd());
     return dirname(dirname(resolve(statePath)));
@@ -410,6 +448,12 @@ function cleanupTmpFiles(statePath) {
                     try {
                         lockTs = parseInt(readFileSync(tsPath, 'utf8').trim(), 10);
                     } catch {}
+                    if (lockPid && String(lockPid) !== String(process.pid) && isPidAlive(parseInt(lockPid, 10))) {
+                        // Dueño vivo = lock activo, haya o no timestamp. Antes un
+                        // lock sin timestamp se borraba igual y se robaba el lock
+                        // de un proceso que estaba escribiendo.
+                        continue;
+                    }
                     if (lockPid && lockTs && !Number.isNaN(lockTs)) {
                         const age = Date.now() - lockTs;
                         if (age < staleWindow && String(lockPid) !== String(process.pid)) {
@@ -617,33 +661,48 @@ class OstackyController {
         const maxAttempts = this.#lockMaxAttempts;
         const lockTimeout = 1000;
         const staleWindow = 15000;
+        const orphanGraceMs = 1000;
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
             try {
-                // Check existing lock BEFORE overwriting — corrects mutual-exclusion bug
+                // Check existing lock BEFORE overwriting — corrects mutual-exclusion bug.
+                // Sin heartbeat legible el lock es huérfano (proceso muerto entre el
+                // write del pid y el del timestamp) o una adquisición en curso. Antes
+                // se seguía derecho al `wx`, que fallaba con EEXIST para siempre: el
+                // controlador no podía persistir NINGUNA decisión y el consume se
+                // perdía (el agente volvía a preguntar ruta/ejecución en loop).
+                let lockAge = NaN;
                 try {
-                    const lockContent = readFileSync(this.#lockHeartbeatPath, 'utf8');
-                    const lockAge = Date.now() - parseInt(lockContent, 10);
-                    if (!Number.isNaN(lockAge) && lockAge < staleWindow) {
-                        const base = Math.min(lockTimeout, 100 * Math.pow(2, attempt));
-                        const jitter = Math.floor(Math.random() * 200) - 100;
-                        const waitMs = Math.max(0, base + jitter);
-                        if (waitMs > 0) await sleep(waitMs);
-                        continue;
-                    }
-                    if (!Number.isNaN(lockAge) && lockAge >= staleWindow) {
-                        try {
-                            const lockPid = readFileSync(this.#lockPidPath, 'utf8').trim();
-                            try {
-                                process.kill(parseInt(lockPid, 10), 0);
-                                // PID alive but stale beyond window — force release
-                            } catch {
-                                // PID dead — force release
-                            }
-                        } catch {}
-                        this.#releaseLock();
-                    }
+                    lockAge = Date.now() - parseInt(readFileSync(this.#lockHeartbeatPath, 'utf8'), 10);
                 } catch {
-                    // No heartbeat file — try to acquire
+                    // sin timestamp
+                }
+                if (!Number.isNaN(lockAge) && lockAge < staleWindow) {
+                    const base = Math.min(lockTimeout, 100 * Math.pow(2, attempt));
+                    const jitter = Math.floor(Math.random() * 200) - 100;
+                    const waitMs = Math.max(0, base + jitter);
+                    if (waitMs > 0) await sleep(waitMs);
+                    continue;
+                }
+                if (!Number.isNaN(lockAge) && lockAge >= staleWindow) {
+                    // Stale: liberar SOLO si el dueño ya no existe. Un dueño vivo
+                    // con heartbeat viejo puede estar en una operación larga:
+                    // robarle el lock haría que su write se pierda. (`#releaseLock`
+                    // no sirve acá: verifica ownership y no toca el lock ajeno, así
+                    // que este camino era un no-op y el lock quedaba pegado.)
+                    const ownerPid = readLockPid(this.#lockPidPath);
+                    if (ownerPid === null || !isPidAlive(ownerPid)) this.#forceReleaseLock();
+                } else if (Number.isNaN(lockAge)) {
+                    const ownerPid = readLockPid(this.#lockPidPath);
+                    // pid ausente, dueño muerto, o pid viejo sin timestamp (crash
+                    // entre los dos writes) → basura: liberar. Un pid recién
+                    // escrito es una adquisición en curso: esperar.
+                    if (
+                        ownerPid === null ||
+                        !isPidAlive(ownerPid) ||
+                        lockPidAgeMs(this.#lockPidPath) > orphanGraceMs
+                    ) {
+                        this.#forceReleaseLock();
+                    }
                 }
                 // Atomic acquire with wx — fails if another process won the race
                 try {
@@ -705,6 +764,25 @@ class OstackyController {
         this.#lockOwner = false;
     }
 
+    /**
+     * Libera un lock que NO es nuestro (huérfano o stale). `#releaseLock` se
+     * niega por diseño a tocar el lock de otro proceso, así que el "force
+     * release" viejo era un no-op y un lock de un proceso muerto quedaba
+     * pegado para siempre (todas las escrituras fallaban con lock timeout).
+     */
+    #forceReleaseLock() {
+        try {
+            unlinkSync(this.#lockPidPath);
+        } catch {
+            /* best-effort */
+        }
+        try {
+            unlinkSync(this.#lockHeartbeatPath);
+        } catch {
+            /* best-effort */
+        }
+    }
+
     #heartbeatLock() {
         if (!this.#lockHeartbeatPath) return;
         try {
@@ -1169,6 +1247,28 @@ class OstackyController {
         };
     }
 
+    /**
+     * multisession-ownership-guard: la request activa es de UNA sesión.
+     * Si el caller es conocido y difiere del dueño, la mutación se rechaza
+     * (consumir/cancelar/refrescar la decisión de otro invalidaba su resumen
+     * y forzaba a re-presentarlo). Sin identidad (clientes legacy sin `_meta`)
+     * o sin dueño, no aplica: comportamiento previo intacto.
+     */
+    async #foreignOwnerError(via) {
+        const owner = this.#state?.ownerSessionId ?? null;
+        const caller = this.#callerSessionId ?? null;
+        if (!owner || !caller || owner === caller) return null;
+        await this.#audit(
+            'WARN',
+            'cross_session_denied',
+            `${via}: caller=${caller} owner=${owner} state=${this.#state?.state}`
+        );
+        return this.#makeError(
+            `BLOCKED: la request activa pertenece a otra sesión (owner=${owner}). No consumas, refresques ni canceles su decisión; usá start_request({force:true}) para takeover explícito o esperá a que termine.`,
+            via
+        );
+    }
+
     #suggestRecovery(state, transition) {
         const suggestions = {
             INTERPRETATION_PENDING: 'Call start_request or proceed_to_discovery first.',
@@ -1240,6 +1340,8 @@ class OstackyController {
 
         const caller = this.#callerSessionId;
         const owner = this.#state.ownerSessionId;
+        const ownerHeartbeat = this.#state.ownerHeartbeat ?? 0;
+        const ownerStale = !ownerHeartbeat || Date.now() - ownerHeartbeat > OWNER_STALE_MS;
         // OJO: `INTERPRETATION_PENDING` está en TERMINAL_STATES — es "terminal" para
         // decidir si se RESUME, pero NO significa que no haya trabajo. Por eso separamos:
         //  - resumeEligible: semántica ORIGINAL de start_request (no la tocamos).
@@ -1250,7 +1352,8 @@ class OstackyController {
             this.#state.state !== STATES.DONE &&
             !!owner &&
             !!caller &&
-            owner !== caller;
+            owner !== caller &&
+            !ownerStale;
 
         // ── Guard de ownership (multi-sesión) ──
         // Si hay una request viva de OTRA sesión y no se fuerza, NO pisamos nada:
@@ -1275,6 +1378,23 @@ class OstackyController {
             };
         }
 
+        // Takeover automático de un dueño muerto (sin `force`): la request no se
+        // pierde, solo cambia de manos. Queda auditado para poder rastrearlo.
+        const staleTakeover =
+            !!owner &&
+            !!caller &&
+            owner !== caller &&
+            ownerStale &&
+            this.#state.state !== STATES.DONE &&
+            !!this.#state.requestId;
+        if (staleTakeover) {
+            await this.#audit(
+                this.#state.state,
+                'session_takeover_stale',
+                `from=${owner} to=${caller} heartbeatAgeMs=${Date.now() - ownerHeartbeat} requestId=${this.#state.requestId}`
+            );
+        }
+
         // If not forcing and current state is active (not terminal), resume instead of reset
         if (!force && resumeEligible) {
             // Reclamamos ownership si no había dueño o si cambió (sesión única / reconexión).
@@ -1558,6 +1678,8 @@ class OstackyController {
 
     async abandon({ reason } = {}) {
         this.#load();
+        const denied = await this.#foreignOwnerError('abandon');
+        if (denied) return denied;
         const to = this.#isAllowedTransition(this.#state.state, 'abandon');
         if (!to) return this.#makeError(`Cannot abandon from state ${this.#state.state}`, 'abandon');
         await this.#transition(to, { error: reason || 'Abandoned' });
@@ -1567,6 +1689,8 @@ class OstackyController {
 
     async consumeRouteDecision({ decisionId, choice } = {}) {
         this.#load();
+        const denied = await this.#foreignOwnerError('consume_route_decision');
+        if (denied) return denied;
         if (choice && !['SPEC', 'DIRECT'].includes(choice)) {
             return { error: `invalid choice: ${choice}`, available: ['SPEC', 'DIRECT'] };
         }
@@ -1906,6 +2030,8 @@ class OstackyController {
 
     async consumeExecutionDecision({ decisionId, mode } = {}) {
         this.#load();
+        const denied = await this.#foreignOwnerError('consume_execution_decision');
+        if (denied) return denied;
         if (mode && !['INLINE', 'SUBAGENT_DRIVEN'].includes(mode)) {
             return { error: `invalid mode: ${mode}`, available: ['INLINE', 'SUBAGENT_DRIVEN'] };
         }
@@ -1944,6 +2070,8 @@ class OstackyController {
      */
     async refreshDecision() {
         this.#load();
+        const denied = await this.#foreignOwnerError('refresh_decision');
+        if (denied) return denied;
         const s = this.#state.state;
         const prevFails = this.#state.consumeFailedCount || 0;
         if (s === 'ROUTE_DECISION_PENDING') {
@@ -2036,15 +2164,19 @@ class OstackyController {
                 const task = this.#state.tasks[tid];
                 if (!task || task.status !== 'COMPLETED') continue;
                 let needle = String(verif).trim();
+                let declaredPath = null;
                 if (needle.startsWith('codegraph:')) needle = needle.slice('codegraph:'.length).trim();
                 else if (needle.startsWith('file:')) {
                     const rest = needle.slice('file:'.length).trim();
                     const parts = rest.split('contiene');
+                    declaredPath = (parts[0] || '').trim() || null;
                     needle = (parts[1] || parts[0] || '').trim() || rest;
                 } else if (needle.startsWith('test:')) continue;
                 if (!needle) continue;
                 let content = null;
-                const fp = task.filePath;
+                // El path de la verificación es la fuente: `task.filePath` puede no
+                // existir (tasks completadas sin archivo declarado).
+                const fp = task.filePath || declaredPath;
                 if (fp) {
                     try {
                         const abs =
@@ -2150,6 +2282,8 @@ class OstackyController {
 
     async block({ reason } = {}) {
         this.#load();
+        const denied = await this.#foreignOwnerError('block');
+        if (denied) return denied;
         const from = this.#state.state;
         const to = this.#isAllowedTransition(this.#state.state, 'block');
         if (!to) return this.#makeError(`Cannot block from state ${this.#state.state}`, 'block');
@@ -2334,10 +2468,12 @@ class OstackyController {
                 if (!task || task.status !== 'COMPLETED') continue;
                 // Re-verificar via file content
                 let needle = String(verif).trim();
+                let declaredPath = null;
                 if (needle.startsWith('codegraph:')) needle = needle.slice('codegraph:'.length).trim();
                 else if (needle.startsWith('file:')) {
                     const rest = needle.slice('file:'.length).trim();
                     const parts = rest.split('contiene');
+                    declaredPath = (parts[0] || '').trim() || null;
                     needle = (parts[1] || parts[0] || '').trim() || rest;
                 } else if (needle.startsWith('test:')) {
                     // test-verification-execution: cierre re-verifica evidencia; antes se salteaba.
@@ -2352,7 +2488,9 @@ class OstackyController {
                 }
                 if (!needle) continue;
                 let content = null;
-                const fp = task.filePath;
+                // El path de la verificación es la fuente: `task.filePath` puede no
+                // existir (tasks completadas sin archivo declarado).
+                const fp = task.filePath || declaredPath;
                 if (fp) {
                     try {
                         const abs =
@@ -2647,11 +2785,34 @@ class OstackyController {
     }
 
     // --- fix-new-file-gate: ligadura validate → complete por filePath (mapa + fallback legacy) ---
+    /**
+     * Clave canónica de `lastValidated`. El plugin escribe paths absolutos y el
+     * agente manda el path relativo (o al revés); comparar por string exacto
+     * hacía que un validate reciente se viera ausente ("validate required").
+     */
+    _validatedKey(filePath) {
+        if (!filePath) return null;
+        try {
+            const abs =
+                filePath.startsWith('/') || /^[A-Za-z]:/.test(filePath)
+                    ? resolve(filePath)
+                    : resolve(getProjectRoot(this.#statePath), filePath);
+            return process.platform === 'win32' ? abs.toLowerCase() : abs;
+        } catch {
+            return filePath;
+        }
+    }
     _getValidatedFor(filePath) {
         const lv = this.#state.lastValidated;
         if (!lv || !filePath) return null;
-        if (lv.byFile && typeof lv.byFile === 'object' && lv.byFile[filePath]) return lv.byFile[filePath];
-        if (lv.filePath === filePath) return lv; // fallback slot legacy (single)
+        const key = this._validatedKey(filePath);
+        if (lv.byFile && typeof lv.byFile === 'object') {
+            if (lv.byFile[filePath]) return lv.byFile[filePath];
+            for (const [k, v] of Object.entries(lv.byFile)) {
+                if (this._validatedKey(k) === key) return v;
+            }
+        }
+        if (lv.filePath && this._validatedKey(lv.filePath) === key) return lv; // fallback slot legacy (single)
         return null;
     }
     async _setValidatedFor(filePath, hash, mode) {
@@ -2679,7 +2840,12 @@ class OstackyController {
     async _clearValidatedFor(filePath) {
         const lv = this.#state.lastValidated;
         if (lv && lv.byFile && typeof lv.byFile === 'object') {
-            if (filePath && lv.byFile[filePath]) delete lv.byFile[filePath];
+            if (filePath) {
+                const key = this._validatedKey(filePath);
+                for (const k of Object.keys(lv.byFile)) {
+                    if (k === filePath || this._validatedKey(k) === key) delete lv.byFile[k];
+                }
+            }
             if (Object.keys(lv.byFile).length === 0) this.#state.lastValidated = null;
             else this.#state.lastValidated = { byFile: lv.byFile, filePath: null, hash: null, ts: Date.now() };
         } else {
@@ -2855,6 +3021,8 @@ class OstackyController {
      */
     async completeTask({ taskId, filePath, fileHash } = {}) {
         this.#load();
+        const denied = await this.#foreignOwnerError('complete_task');
+        if (denied) return denied;
         if (this.#state.state !== 'EXECUTING_INLINE' && this.#state.state !== 'EXECUTING_SUBAGENTS') {
             return this.#makeError(`Cannot complete task from state ${this.#state.state}`, 'complete_task');
         }
@@ -3236,19 +3404,39 @@ function extractCallerSessionId(ctx) {
     return null;
 }
 
+// ── Cola in-process (fix-consume-race-lock) ──────────────────────────────────
+// Code Mode emite varias tools en paralelo DENTRO del mismo proceso MCP y
+// `#state` es un único objeto compartido. Un `reloadFresh()` concurrente (p.ej.
+// un `get_state` en el mismo batch) reemplazaba `#state` mientras otro handler
+// tenía una transición en vuelo: el `#persist` serializaba el snapshot viejo y
+// el `consume_*` se perdía. El disco quedaba en `*_PENDING` y el agente volvía
+// a preguntar DIRECT/SPEC e INLINE/SUBAGENT. Serializar restaura el invariante
+// "un read-modify-write a la vez" también in-process.
+let opQueue = Promise.resolve();
+
+export function serializeOp(run) {
+    const next = opQueue.then(run, run);
+    opQueue = next.then(
+        () => {},
+        () => {}
+    );
+    return next;
+}
+
 function safeHandler(fn, options = {}) {
     const { maxRetries = 0, baseTimeout = 5000 } = options;
 
-    return async (params, ctx) => {
+    return (params, ctx) => serializeOp(async () => {
         // ── multi-sesión: identidad + estado fresco + lock por operación ──
-        // 1) sessionId del caller (de `_meta`), 2) re-lectura fresca desde disco
-        // (mata el snapshot congelado del cache `#loaded` cuando hay 2+ procesos),
-        // 3) lock reentrante durante TODO el read-modify-write → sin lost updates.
+        // 1) sessionId del caller (de `_meta`), 2) lock durante TODO el
+        // read-modify-write, 3) re-lectura fresca DENTRO del lock: leer antes de
+        // tomarlo dejaba una ventana donde otro proceso escribía y el persist
+        // posterior revertía esa escritura (lost update).
         let heldLock = false;
         try {
             controller.setCallerSession(extractCallerSessionId(ctx));
-            controller.reloadFresh();
             heldLock = await controller.beginWrite();
+            controller.reloadFresh();
         } catch {}
         const endOp = () => {
             if (!heldLock) return;
@@ -3327,12 +3515,12 @@ function safeHandler(fn, options = {}) {
                 };
             }
         }
-    };
+        });
 }
 
 const server = new McpServer({
     name: 'ostacky-controller',
-    version: '0.10.1',
+    version: '0.10.3',
 });
 
 server.registerTool(
@@ -3934,7 +4122,7 @@ function setupGracefulShutdown(ctrl) {
 }
 
 async function main() {
-    log('Starting ostacky-controller MCP v0.10.1...');
+    log('Starting ostacky-controller MCP v0.10.3...');
     log('State path:', { path: statePath });
     // Clean up stale tmp/lock files from previous runs
     cleanupTmpFiles(statePath);

package/assets/plugins/engram.ts

@@ -575,17 +575,21 @@ export default {
         // 2) try local opencode.json / jsonc in project
         if (!statePath) {
           const candidates = [join(directory, "opencode.json"), join(directory, "opencode.jsonc")]
-          // also try global config (XDG / APPDATA)
+          // also try global config (OPENCODE_CONFIG_DIR / XDG / ~/.config)
           try {
+            const explicit = process.env.OPENCODE_CONFIG_DIR?.trim()
             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"))
-              }
+            const xdg = process.env.XDG_CONFIG_HOME?.trim()
+            const globalDir = explicit
+              ? explicit
+              : xdg
+                ? join(xdg, "opencode")
+                : home
+                  ? join(home, ".config", "opencode")
+                  : ""
+            if (globalDir) {
+              candidates.push(join(globalDir, "opencode.json"))
+              candidates.push(join(globalDir, "opencode.jsonc"))
             }
           } catch {}
           for (const cand of candidates) {