ostacky 0.9.7 → 0.10.1

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

@@ -215,7 +215,10 @@ export function parseTaskVerifications(changeId, statePath) {
             if (!m) continue;
             const id = m[1];
             if (!isValidTaskId(id)) continue;
-            const idx = line.indexOf('verificar:');
+            // lastIndexOf: la convención es que el marker va al FINAL de la línea. Con indexOf,
+            // una task que MENCIONA el formato en su descripción ("usá — verificar: file:...") se
+            // parseaba a sí misma mal: ganaba el ejemplo, no el marker real.
+            const idx = line.lastIndexOf('verificar:');
             if (idx !== -1) {
                 const v = line
                     .slice(idx + 'verificar:'.length)
@@ -230,6 +233,35 @@ export function parseTaskVerifications(changeId, statePath) {
     }
 }
 
+/**
+ * test-verification-execution: evidencia real de una corrida de test.
+ *
+ * NO usa `status`: el shell tool de OpenCode reporta "completed" incluso con
+ * exit != 0 (medido: `sh -c 'exit 3'` -> status "completed", metadata.exit 3).
+ * El plugin registra {cmd, exit, ts} por cada shell; acá sólo se acepta el
+ * comando exacto, exit 0, y posterior a la última mutación.
+ */
+export function findTestEvidence({ runs, cmd, lastMutationTs, now = Date.now() } = {}) {
+    const expected = String(cmd || '').trim();
+    if (!expected) return { ok: false, reason: 'test: sin comando' };
+    if (!Array.isArray(runs) || runs.length === 0)
+        return { ok: false, reason: 'sin evidencia: el plugin no registró corridas de shell (¿está corriendo?)' };
+    const matches = runs.filter((r) => r && String(r.cmd || '').trim() === expected);
+    if (matches.length === 0) return { ok: false, reason: `nunca se ejecutó exactamente "${expected}"` };
+    const last = matches.reduce((a, b) => ((Number(b.ts) || 0) >= (Number(a.ts) || 0) ? b : a));
+    if (typeof last.ts !== 'number' || typeof lastMutationTs !== 'number')
+        return {
+            ok: false,
+            reason: `sin timestamps: no se puede probar que "${expected}" sea posterior a la última edición`,
+            run: last,
+        };
+    if (last.ts <= lastMutationTs)
+        return { ok: false, reason: `la última corrida de "${expected}" es anterior a la última edición`, run: last };
+    if (last.exit !== 0)
+        return { ok: false, reason: `la última corrida de "${expected}" salió con exit ${last.exit}`, run: last };
+    return { ok: true, reason: `exit 0 hace ${Math.max(0, Math.round((now - last.ts) / 1000))}s`, run: last };
+}
+
 function isValidTaskId(taskId) {
     return typeof taskId === 'string' && /^[a-zA-Z0-9-_.\/:]+$/.test(taskId);
 }
@@ -446,6 +478,11 @@ class OstackyController {
     #lockHeartbeatPath;
     #lockMaxAttempts = 5; // C1: 10→5 with jitter, overridable via opts for fast tests
     #lockOwner = false;
+    #lockDepth = 0; // multi-sesión: reentrancy (el lock se toma una vez por tool call)
+    #callerSessionId = null; // sessionId del caller (de _meta), solo en memoria
+    #loadedSnapshot = null; // huella del estado recién leído, para detectar "dirty"
+    #persistQueue = Promise.resolve(); // cola in-process: las escrituras nunca se solapan
+    #persistSeq = 0; // sufijo único por escritura (tmp.<pid>.<seq>)
 
     constructor(opts = {}) {
         this.#statePath = opts.statePath;
@@ -484,6 +521,76 @@ class OstackyController {
         }
     }
 
+    // ─── multi-sesión ────────────────────────────────────────────────────────
+    /**
+     * Re-lectura fresca desde disco. Invalida el cache #loaded y reusa la lógica
+     * de #load() (migraciones + fallback de backups). Se llama al INICIO de cada
+     * tool call, así dos procesos/sesiones nunca operan sobre un snapshot viejo
+     * (antes: `if (this.#loaded) return` hacía que el estado quedara congelado).
+     */
+    reloadFresh() {
+        this.#loaded = false;
+        this.#load();
+        this.#loadedSnapshot = this.#diffableState();
+    }
+
+    /**
+     * Huella serializada del estado (para el diff de "dirty").
+     * Excluye `lastHeartbeat` porque se actualiza en cada tool call y no debe
+     * forzar una escritura a disco (rotaría backups sin cambios reales).
+     */
+    #diffableState() {
+        if (!this.#state) return '';
+        try {
+            return safeJsonStringify({ ...this.#state, lastHeartbeat: 0 });
+        } catch {
+            return '';
+        }
+    }
+
+    /**
+     * Persiste si hubo mutaciones en memoria respecto de la última lectura/escritura.
+     * Es OBLIGATORIO ahora que reloadFresh() descarta el estado en memoria al inicio
+     * de cada tool call: sin esto, una mutación que no llamó a #persist (p.ej. el
+     * buffer de auditoría, o los campos de ownership) se perdería al siguiente call.
+     */
+    async persistIfDirty() {
+        if (!this.#statePath || !this.#state) return false;
+        // Drenar auditoría pendiente: el buffer vive solo en memoria, así que si no
+        // lo volcamos acá se perdería en el próximo reloadFresh().
+        try {
+            if (this.#auditBuffer.length > 0) await this.#flushAudit(false);
+        } catch {}
+        if (this.#diffableState() === this.#loadedSnapshot) return false;
+        await this.#persist();
+        this.#loadedSnapshot = this.#diffableState();
+        return true;
+    }
+
+    /** Registra el sessionId del caller actual (de `_meta["ai.opencode/sessionID"]`). */
+    setCallerSession(sessionId) {
+        this.#callerSessionId = typeof sessionId === 'string' && sessionId ? sessionId : null;
+    }
+
+    /** sessionId del caller actual, o null si el cliente no lo mandó. */
+    get callerSessionId() {
+        return this.#callerSessionId;
+    }
+
+    /**
+     * Toma el lock de estado por toda la duración de un tool call (read-modify-write
+     * serializado entre procesos/sesiones). Reentrante: #persist puede volver a
+     * pedirlo dentro de la misma operación.
+     */
+    async beginWrite() {
+        return this.#acquireLock();
+    }
+
+    /** Libera el lock tomado por beginWrite (reentrante). */
+    endWrite() {
+        this.#releaseLock();
+    }
+
     /**
      * Validates that a parsed state object has the required fields and valid values.
      * Returns null if valid, or an error message if invalid.
@@ -500,6 +607,13 @@ class OstackyController {
     // --- 3.4: State file locking (C1 fix: check stale BEFORE write, atomic wx, jitter, 15s stale, 1s timeout) ---
     async #acquireLock() {
         if (!this.#lockPath) return true;
+        // Reentrante: el boundary del tool ya tomó el lock (beginWrite) y #persist lo
+        // vuelve a pedir dentro de la MISMA operación. Sin esto, el segundo intento
+        // chocaba con nuestro propio lock (EEXIST) y hacía fallar la persistencia.
+        if (this.#lockDepth > 0) {
+            this.#lockDepth++;
+            return true;
+        }
         const maxAttempts = this.#lockMaxAttempts;
         const lockTimeout = 1000;
         const staleWindow = 15000;
@@ -546,6 +660,7 @@ class OstackyController {
                 }
                 this.#heartbeatLock();
                 this.#lockOwner = true;
+                this.#lockDepth = 1;
                 return true;
             } catch {
                 const base = Math.min(lockTimeout, 100 * Math.pow(2, attempt));
@@ -561,6 +676,12 @@ class OstackyController {
 
     #releaseLock() {
         if (!this.#lockPath) return;
+        // Reentrante: solo el nivel más externo libera de verdad.
+        if (this.#lockDepth > 1) {
+            this.#lockDepth--;
+            return;
+        }
+        this.#lockDepth = 0;
         // D2: verify ownership before deleting — never delete another process's lock
         try {
             const ownerPid = readFileSync(this.#lockPidPath, 'utf8').trim();
@@ -743,7 +864,24 @@ class OstackyController {
         this.#loaded = true;
     }
 
-    async #persist() {
+    /**
+     * Serializa las escrituras de estado DENTRO del proceso.
+     * Sin esto, un flush fire-and-forget (#enterDegradedMode/#exitDegradedMode) o un
+     * flush del watchdog puede interleavearse con el persist de un handler: ambos
+     * escriben el MISMO `tmp.<pid>` y el segundo rename falla con ENOENT (o, peor,
+     * se pierde la escritura). Ahora las escrituras se encolan: nunca se solapan.
+     */
+    #persist() {
+        const run = () => this.#persistInner();
+        const next = this.#persistQueue.then(run, run);
+        this.#persistQueue = next.then(
+            () => {},
+            () => {}
+        );
+        return next;
+    }
+
+    async #persistInner() {
         if (!this.#statePath) return;
 
         const dir = dirname(this.#statePath);
@@ -818,7 +956,7 @@ class OstackyController {
                 stateForSerialize.snapshots = { codegraph: null, execution: null };
                 serialized = safeJsonStringify(stateForSerialize, true);
             }
-            const tmp = this.#statePath + '.tmp.' + process.pid;
+            const tmp = this.#statePath + '.tmp.' + process.pid + '.' + ++this.#persistSeq;
             await writeFileAsync(tmp, serialized, 'utf8');
             await renameAsync(tmp, this.#statePath);
             // 2.1: backup rotativo 3 niveles best-effort
@@ -1100,25 +1238,79 @@ class OstackyController {
     async startRequest({ requestId, changeId, force = false } = {}) {
         this.#load();
 
+        const caller = this.#callerSessionId;
+        const owner = this.#state.ownerSessionId;
+        // 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).
+        //  - foreignOwnedWork: hay una request de OTRA sesión que todavía no terminó.
+        const resumeEligible = !TERMINAL_STATES.includes(this.#state.state) && !!this.#state.requestId;
+        const foreignOwnedWork =
+            !!this.#state.requestId &&
+            this.#state.state !== STATES.DONE &&
+            !!owner &&
+            !!caller &&
+            owner !== caller;
+
+        // ── Guard de ownership (multi-sesión) ──
+        // Si hay una request viva de OTRA sesión y no se fuerza, NO pisamos nada:
+        // devolvemos el estado real para que el caller haga un takeover explícito
+        // (force:true, auditado). Sin caller conocido (clientes que no mandan `_meta`)
+        // el guard no aplica: comportamiento idéntico al anterior.
+        if (foreignOwnedWork && !force) {
+            await this.#audit(
+                this.#state.state,
+                'start_request_conflict',
+                `caller=${caller} owner=${owner} requestId=${this.#state.requestId}`
+            );
+            return {
+                conflict: true,
+                state: this.#state.state,
+                revision: this.#state.revision,
+                requestId: this.#state.requestId,
+                ownerSessionId: owner,
+                callerSessionId: caller,
+                message:
+                    'Otra sesión posee la request activa. Reintentá con force:true para hacer takeover (queda auditado).',
+            };
+        }
+
         // If not forcing and current state is active (not terminal), resume instead of reset
-        if (!force && !TERMINAL_STATES.includes(this.#state.state) && this.#state.requestId) {
+        if (!force && resumeEligible) {
+            // Reclamamos ownership si no había dueño o si cambió (sesión única / reconexión).
+            if (caller && this.#state.ownerSessionId !== caller) {
+                this.#state.ownerSessionId = caller;
+            }
+            this.#state.ownerHeartbeat = Date.now();
             await this.#audit(
                 this.#state.state,
                 'start_request',
-                `resumed from ${this.#state.state}, requestId=${this.#state.requestId}`
+                `resumed from ${this.#state.state}, requestId=${this.#state.requestId}${caller ? `, session=${caller}` : ''}`
             );
             return {
                 state: this.#state.state,
                 revision: this.#state.revision,
                 requestId: this.#state.requestId,
+                ownerSessionId: this.#state.ownerSessionId,
                 continued: true,
             };
         }
 
+        // Takeover EXPLÍCITO (force sobre una request viva de otra sesión) → auditado
+        if (force && foreignOwnedWork) {
+            await this.#audit(
+                this.#state.state,
+                'session_takeover',
+                `from=${owner} to=${caller} requestId=${this.#state.requestId}`
+            );
+        }
+
         // Force reset or terminal state: create new session
         await this.#transition('INTERPRETATION_PENDING', {
             requestId: requestId || 'req-' + Date.now(),
             changeId: changeId || null,
+            ownerSessionId: caller || null,
+            ownerHeartbeat: Date.now(),
             routeDecisionId: null,
             routeChoice: null,
             executionDecisionId: null,
@@ -1140,6 +1332,7 @@ class OstackyController {
             state: this.#state.state,
             revision: this.#state.revision,
             requestId: this.#state.requestId,
+            ownerSessionId: this.#state.ownerSessionId,
             continued: false,
         };
     }
@@ -1563,6 +1756,14 @@ class OstackyController {
             expectedTasks = [...tasksMdIds];
             expectedTaskCount = tasksMdIds.length;
         }
+        // task-verification-integrity D1: las verificaciones viajan con el MISMO parse de
+        // tasks.md que ya usa expectedTasks. Antes sólo las cargaba set_expected_tasks, una
+        // tool que el prompt nunca menciona -> `— verificar:` quedaba muerto en la práctica.
+        let taskVerifs = null;
+        try {
+            const parsedVerifs = parseTaskVerifications(this.#state.changeId, this.#statePath);
+            taskVerifs = Object.keys(parsedVerifs).length ? parsedVerifs : null;
+        } catch {}
         // 8.1/8.2: lastProposal for execution — reasoning con plan
         let execShown = false;
         let execFiles = [];
@@ -1602,6 +1803,7 @@ class OstackyController {
             snapshots: { ...this.#state.snapshots, execution: snapshot ? structuredClone(snapshot) : null },
             expectedTasks: Array.isArray(expectedTasks) ? [...expectedTasks] : null,
             expectedTaskCount: typeof expectedTaskCount === 'number' ? expectedTaskCount : null,
+            taskVerifications: taskVerifs,
             lastProposal: execLastProposal,
         });
         await this.#audit('EXECUTION_DECISION_PENDING', 'record_execution_analysis');
@@ -1653,20 +1855,11 @@ class OstackyController {
         }
         // C2: warning if missing codegraphUsed+recommendation and not degraded — snapshot missing also counts
         // 1.7: early-exit with taskCount<=2 is valid without codegraphUsed, do not warn
-        // mejora-acciones-controller F3: discovery-cache counts as valid evidence if discovery snapshot exists
-        const isDiscoveryCacheEvidence =
-            snapshot &&
-            Array.isArray(snapshot.codegraphUsed) &&
-            snapshot.codegraphUsed.includes('discovery-cache') &&
-            this.#state.snapshots.codegraph != null &&
-            Array.isArray(snapshot.expectedTaskIds) &&
-            snapshot.expectedTaskIds.length > 0;
         const hasEvidence =
             (snapshot &&
                 Array.isArray(snapshot.codegraphUsed) &&
                 snapshot.codegraphUsed.length > 0 &&
-                snapshot.recommendation != null) ||
-            isDiscoveryCacheEvidence;
+                snapshot.recommendation != null);
         if (!hasEvidence && !this.#degraded && !isEarlyExitExec) {
             this.#state.codegraphBypassCount = (this.#state.codegraphBypassCount || 0) + 1;
             const auditId = `aud-${Date.now()}-${this.#state.auditSeq}`;
@@ -1770,6 +1963,25 @@ class OstackyController {
         return this.#makeError(`No decision to refresh from state ${s}`, 'refresh_decision');
     }
 
+    /**
+     * task-verification-integrity D3: si el estado no tiene expectedTasks ni expectedTaskCount,
+     * leer la fuente (tasks.md) en el momento del gate. El gate no puede quedar vacío sólo
+     * porque record_execution_analysis nunca corrió o el cache se perdió.
+     * Devuelve null cuando no hay tasks.md (trabajo no-spec: sin gate) o cuando manda el count.
+     */
+    #deriveExpectedTasks() {
+        if (Array.isArray(this.#state.expectedTasks) && this.#state.expectedTasks.length > 0) {
+            return this.#state.expectedTasks;
+        }
+        if (typeof this.#state.expectedTaskCount === 'number') return null;
+        try {
+            const ids = parseTasksMd(this.#state.changeId, this.#statePath);
+            return ids.length > 0 ? ids : null;
+        } catch {
+            return null;
+        }
+    }
+
     async implementationComplete({ force } = {}) {
         this.#load();
         const to = this.#isAllowedTransition(this.#state.state, 'implementation_complete');
@@ -1779,9 +1991,11 @@ class OstackyController {
                 'implementation_complete'
             );
         // C2 gate: check expectedTasks vs completed — do NOT transition if pending and not forced
+        // D3: un cache vacío no vacía el gate — se deriva de tasks.md.
+        const derivedExpected = this.#deriveExpectedTasks();
         let pending = [];
-        if (Array.isArray(this.#state.expectedTasks) && this.#state.expectedTasks.length > 0) {
-            pending = this.#state.expectedTasks.filter(
+        if (Array.isArray(derivedExpected) && derivedExpected.length > 0) {
+            pending = derivedExpected.filter(
                 (id) => !this.#state.tasks[id] || this.#state.tasks[id].status !== 'COMPLETED'
             );
         } else if (typeof this.#state.expectedTaskCount === 'number') {
@@ -1794,7 +2008,14 @@ class OstackyController {
         const seenFp2 = new Set();
         try {
             for (const [taskId, info] of Object.entries(this.#state.tasks || {})) {
-                if (info.status !== 'COMPLETED' || !info.filePath || !info.fileHash) continue;
+                if (info.status !== 'COMPLETED' || !info.filePath) continue;
+                // task-verification-integrity D2: COMPLETED con filePath y sin hash es un fantasma
+                // (complete_task lo aceptaba); antes se salteaba y quedaba invisible al cierre.
+                if (!info.fileHash) {
+                    staleFiles.push(`${taskId}:${info.filePath} (missing hash)`);
+                    seenFp2.add(info.filePath);
+                    continue;
+                }
                 const current = fingerprintFor(info.filePath, this.#statePath);
                 if (!current) staleFiles.push(`${taskId}:${info.filePath} (missing)`);
                 else if (current !== info.fileHash) staleFiles.push(`${taskId}:${info.filePath} (stale fingerprint)`);
@@ -1866,10 +2087,27 @@ class OstackyController {
             };
         }
         if (hasBlocking && force) {
-            // 4.3: force requiere confirmación humana en últimas 5 entradas de audit
-            const recentAudit = [...(this.#state.audit || []).slice(-5), ...this.#auditBuffer.slice(-5)];
-            const hasHuman = recentAudit.some((e) => e.reasoning && /forzar|confirmo|force/i.test(e.reasoning));
+            // task-verification-integrity D4: la evidencia es el TEXTO DEL USUARIO, no el audit.
+            // El audit lo redacta el agente: aceptar /forzar|confirmo|force/ ahí era self-attestation
+            // (cualquier tool call con esa palabra abría el gate). El plugin registra lastUserPrompts
+            // desde ctx.session.hook("prompt"), antes de inyectar hints.
+            // Durden: cada prompt lleva ts y cada rechazo setea lastForceAttemptTs — sólo
+            // cuenta una confirmación POSTERIOR al último intento ("¿qué hace force:true?"
+            // previo al attempt ya no habilita). Strings sin ts = estado legacy: válidos
+            // sólo si nunca hubo intento registrado.
+            const userPrompts = Array.isArray(this.#state.lastUserPrompts) ? this.#state.lastUserPrompts : [];
+            const lastAttempt = Number(this.#state.lastForceAttemptTs) || 0;
+            const isUserPhrase = (p) => {
+                const text = typeof p === 'string' ? p : typeof p?.text === 'string' ? p.text : null;
+                if (!text || !/forzar|confirmo|force/i.test(text)) return false;
+                const ts = typeof p?.ts === 'number' ? p.ts : null;
+                if (ts === null) return lastAttempt === 0;
+                return ts > lastAttempt;
+            };
+            const hasHuman = userPrompts.some(isUserPhrase);
             if (!hasHuman) {
+                this.#state.lastForceAttemptTs = Date.now();
+                await this.#persist();
                 const pendingMsg =
                     pending.length > 0 ? `Te faltan ${pending.length} task(s): ${pending.join(', ')}.` : '';
                 const staleMsg = staleFiles.length > 0 ? `Archivos stale: ${staleFiles.join(', ')}.` : '';
@@ -1883,7 +2121,7 @@ class OstackyController {
                     verificationFailed: verificationFailed.length ? verificationFailed : undefined,
                     current_state: this.#state.state,
                     attempted_transition: 'implementation_complete',
-                    suggestion: `${detail} Para forzar el cierre, escribí literal "confirmo forzar" en tu mensaje (quedará auditado) y reintentá con {force:true}. Si no querés forzar y es solo stale por refino, llamá refresh_fingerprint({filePath}) y reintentá sin force.`,
+                    suggestion: `${detail} Para forzar el cierre, el USUARIO debe escribir literal "confirmo forzar" en un mensaje NUEVO suyo (el plugin lo registra con timestamp; una frase previa a este aviso no cuenta, y el audit que redacta el agente tampoco) y luego reintentá con {force:true}. Si no querés forzar y es solo stale por refino, llamá refresh_fingerprint({filePath}) y reintentá sin force.`,
                 };
             }
             const all = [...pending, ...staleFiles, ...verificationFailed].join(',');
@@ -2051,9 +2289,11 @@ class OstackyController {
 
     async verifyIntegrity() {
         this.#load();
+        // D3: un cache vacío no vacía el gate — se deriva de tasks.md.
+        const derivedExpected = this.#deriveExpectedTasks();
         let pending = [];
-        if (Array.isArray(this.#state.expectedTasks) && this.#state.expectedTasks.length > 0) {
-            pending = this.#state.expectedTasks.filter(
+        if (Array.isArray(derivedExpected) && derivedExpected.length > 0) {
+            pending = derivedExpected.filter(
                 (id) => !this.#state.tasks[id] || this.#state.tasks[id].status !== 'COMPLETED'
             );
         } else if (typeof this.#state.expectedTaskCount === 'number') {
@@ -2066,7 +2306,13 @@ class OstackyController {
         const seenFp = new Set();
         try {
             for (const [taskId, info] of Object.entries(this.#state.tasks || {})) {
-                if (info.status !== 'COMPLETED' || !info.filePath || !info.fileHash) continue;
+                if (info.status !== 'COMPLETED' || !info.filePath) continue;
+                // task-verification-integrity D2: COMPLETED con filePath y sin hash es un fantasma
+                if (!info.fileHash) {
+                    staleFiles.push(`${taskId}:${info.filePath} (missing hash)`);
+                    seenFp.add(info.filePath);
+                    continue;
+                }
                 const current = fingerprintFor(info.filePath, this.#statePath);
                 if (!current) staleFiles.push(`${taskId}:${info.filePath} (missing)`);
                 else if (current !== info.fileHash) staleFiles.push(`${taskId}:${info.filePath} (stale fingerprint)`);
@@ -2094,7 +2340,14 @@ class OstackyController {
                     const parts = rest.split('contiene');
                     needle = (parts[1] || parts[0] || '').trim() || rest;
                 } else if (needle.startsWith('test:')) {
-                    // test: asumimos ok si ya está completa (test se corrió en agente)
+                    // test-verification-execution: cierre re-verifica evidencia; antes se salteaba.
+                    const cmd = needle.slice('test:'.length).trim();
+                    const ev = findTestEvidence({
+                        runs: this.#state.shellRuns,
+                        cmd,
+                        lastMutationTs: this.#state.lastMutationTs,
+                    });
+                    if (!ev.ok) verificationFailed.push(`${tid}: ${verif} — ${ev.reason}`);
                     continue;
                 }
                 if (!needle) continue;
@@ -2189,6 +2442,15 @@ class OstackyController {
         return {
             revision: this.#state.revision,
             state: this.#state.state,
+            // multi-sesión: quién posee la request y quién está preguntando AHORA.
+            // Se calcula con el callerSessionId de ESTA llamada (no está persistido).
+            ownership: {
+                ownerSessionId: this.#state.ownerSessionId ?? null,
+                callerSessionId: this.#callerSessionId,
+                isOwner:
+                    !!this.#callerSessionId && this.#callerSessionId === (this.#state.ownerSessionId ?? null),
+                ownerHeartbeat: this.#state.ownerHeartbeat ?? 0,
+            },
             degraded: this.#degraded || !!this.#state.degraded,
             consecutiveFailures: this.#consecutiveFailures,
             taskCounts: {
@@ -2366,7 +2628,9 @@ class OstackyController {
 
     async getState() {
         this.#load();
-        return structuredClone(this.#state);
+        // callerSessionId es de la llamada actual (no del estado persistido):
+        // permite verificar de un vistazo qué sesión está operando.
+        return { ...structuredClone(this.#state), callerSessionId: this.#callerSessionId };
     }
 
     async getTasks() {
@@ -2618,6 +2882,19 @@ class OstackyController {
         // Generico: test: tasks no requieren archivo nuevo (son verificaciones de comportamiento)
         const verifEarly = this.#state.taskVerifications?.[taskId];
         const isTestTaskEarly = verifEarly && verifEarly.trim().startsWith('test:');
+        // task-verification-integrity D2: un filePath que no existe no puede quedar COMPLETED.
+        // Antes se aceptaba con fileHash:null y verifyIntegrity lo salteaba -> fantasma invisible.
+        // Sin excepción por tipo de task: un path declarado debe existir; una task `test:` no
+        // necesita declarar filePath (y si lo declara, ese archivo ya se creó antes de completarla).
+        if (filePath) {
+            const absPath =
+                filePath.startsWith('/') || /^[A-Za-z]:/.test(filePath)
+                    ? resolve(filePath)
+                    : resolve(getProjectRoot(this.#statePath), filePath);
+            if (!existsSync(absPath)) {
+                return { error: `filePath does not exist: ${filePath}`, taskId, filePath };
+            }
+        }
         const isNewFile = !!(
             isTestTaskEarly ||
             (filePath &&
@@ -2655,7 +2932,7 @@ class OstackyController {
                     `task ${taskId} verification failed: ${verifForComplete}`
                 );
                 return {
-                    error: `verification failed for ${taskId}: ${verifForComplete} not found in ${vres.fileHint || filePath || 'unknown file'}`,
+                    error: `verification failed for ${taskId}: ${verifForComplete} — ${vres.reason || `not found in ${vres.fileHint || filePath || 'unknown file'}`}`,
                     taskId,
                     verification: verifForComplete,
                     verificationFailed: true,
@@ -2795,14 +3072,27 @@ class OstackyController {
                 else fileHint = fileHint || info?.filePath || null;
                 if (!needle) needle = rest;
             } else if (needle.startsWith('test:')) {
-                // test: no podemos ejecutar desde controller, consideramos ok si hay filePath (ya editado) o fileHash
-                needle = needle.slice('test:'.length).trim();
-                const hasFile = !!(fileHint || info?.filePath || info?.fileHash);
-                const ok = hasFile;
+                // test-verification-execution: evidencia real registrada por el plugin
+                // (exit + timestamp). Nunca "assumed ok"; el comando debe coincidir exacto.
+                const cmd = needle.slice('test:'.length).trim();
+                const ev = findTestEvidence({
+                    runs: this.#state.shellRuns,
+                    cmd,
+                    lastMutationTs: this.#state.lastMutationTs,
+                });
                 if (!this.#state.taskVerificationResults) this.#state.taskVerificationResults = {};
-                this.#state.taskVerificationResults[taskId] = { ok, verif, ts: Date.now() };
+                this.#state.taskVerificationResults[taskId] = {
+                    ok: ev.ok,
+                    verif,
+                    reason: ev.reason,
+                    // Copia plana, NO la referencia de shellRuns: el serializador seguro
+                    // marca referencias repetidas como "[Circular]" y corrompería la
+                    // evidencia persistida (bug detectado por el test de integración).
+                    run: ev.run ? { cmd: ev.run.cmd, exit: ev.run.exit, ts: ev.run.ts } : null,
+                    ts: Date.now(),
+                };
                 await this.#persist();
-                return { ok, taskId, verif, reason: hasFile ? 'test verification assumed ok (has file)' : 'no file' };
+                return { ok: ev.ok, taskId, verif, command: cmd, reason: ev.reason, run: ev.run };
             }
             // Generic: check file content contains needle
             let content = null;
@@ -2924,16 +3214,55 @@ const controller = new OstackyController({ statePath });
  * @param {number} options.maxRetries - Maximum retry attempts (default: 0)
  * @param {number} options.baseTimeout - Base timeout in ms (default: 5000)
  */
+/**
+ * Extrae el sessionId de OpenCode del contexto del request.
+ * OpenCode lo manda como `_meta["ai.opencode/sessionID"]` en cada tools/call
+ * (aplica a tools directos y a Code Mode; puede faltar → degradamos a null,
+ * y con null NO se aplica guard de ownership para no romper clientes viejos).
+ */
+function extractCallerSessionId(ctx) {
+    try {
+        const meta = ctx && ctx.mcpReq && ctx.mcpReq._meta;
+        if (meta && typeof meta === 'object') {
+            const v = meta['ai.opencode/sessionID'];
+            if (typeof v === 'string' && v) return v;
+        }
+    } catch {}
+    // Fallback: sessionId del transporte (stdio → puede ser único por proceso,
+    // NO por sesión de OpenCode; por eso es solo fallback).
+    try {
+        if (ctx && typeof ctx.sessionId === 'string' && ctx.sessionId) return ctx.sessionId;
+    } catch {}
+    return null;
+}
+
 function safeHandler(fn, options = {}) {
     const { maxRetries = 0, baseTimeout = 5000 } = options;
 
-    return async (params) => {
+    return async (params, ctx) => {
+        // ── 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.
+        let heldLock = false;
+        try {
+            controller.setCallerSession(extractCallerSessionId(ctx));
+            controller.reloadFresh();
+            heldLock = await controller.beginWrite();
+        } catch {}
+        const endOp = () => {
+            if (!heldLock) return;
+            heldLock = false;
+            try {
+                controller.endWrite();
+            } catch {}
+        };
         for (let attempt = 0; attempt <= maxRetries; attempt++) {
             const currentTimeout = baseTimeout * Math.pow(1.5, attempt);
             const start = Date.now();
             try {
                 const result = await Promise.race([
-                    fn(params),
+                    fn(params, ctx),
                     new Promise((_, reject) =>
                         setTimeout(() => reject(new Error(`timeout ${currentTimeout}ms`)), currentTimeout)
                     ),
@@ -2942,8 +3271,13 @@ function safeHandler(fn, options = {}) {
                 try {
                     await controller._recordToolDuration(duration);
                 } catch {}
+                // Flush si el handler mutó el estado sin persistir (audit buffer, ownership…)
+                try {
+                    await controller.persistIfDirty();
+                } catch {}
                 // Update heartbeat on successful completion
                 controller.updateHeartbeat();
+                endOp();
                 return { content: [{ type: 'text', text: safeJsonStringify(result) }] };
             } catch (error) {
                 const isTimeout = error && error.message && error.message.includes('timeout');
@@ -2969,6 +3303,7 @@ function safeHandler(fn, options = {}) {
                     try {
                         await controller._recordToolTimeout();
                     } catch {}
+                    endOp();
                     return {
                         content: [
                             {
@@ -2985,6 +3320,7 @@ function safeHandler(fn, options = {}) {
                     error: error.message,
                     stack: error.stack,
                 });
+                endOp();
                 return {
                     content: [{ type: 'text', text: safeJsonStringify({ error: error.message }) }],
                     isError: true,
@@ -2996,7 +3332,7 @@ function safeHandler(fn, options = {}) {
 
 const server = new McpServer({
     name: 'ostacky-controller',
-    version: '0.9.7',
+    version: '0.10.1',
 });
 
 server.registerTool(
@@ -3598,7 +3934,7 @@ function setupGracefulShutdown(ctrl) {
 }
 
 async function main() {
-    log('Starting ostacky-controller MCP v0.9.7...');
+    log('Starting ostacky-controller MCP v0.10.1...');
     log('State path:', { path: statePath });
     // Clean up stale tmp/lock files from previous runs
     cleanupTmpFiles(statePath);