sinapse-ai 1.17.0 → 1.19.1

package/.sinapse-ai/core/orchestration/executors/epic-4-executor.js

@@ -13,6 +13,7 @@
 
 const fs = require('fs-extra');
 const path = require('path');
+const yaml = require('js-yaml');
 const EpicExecutor = require('./epic-executor');
 
 /**
@@ -115,6 +116,9 @@ class Epic4Executor extends EpicExecutor {
           return this._completeExecution({
             implementationPath: planPath,
             planPath,
+            // F5 (epic: orchestration-consolidation): propagate the real plan object
+            // so the downstream epic4_to_epic6 gate can verify it is not degraded/stub.
+            plan: buildResult.plan,
             build: buildResult,
             reportPath: buildResult.reportPath,
             phases: buildResult.phases,
@@ -212,44 +216,47 @@ class Epic4Executor extends EpicExecutor {
    * @private
    */
   async _createStubPlan(planPath, storyId, specPath) {
-    const stubPlan = `# Implementation Plan: ${storyId}
-# Generated: ${new Date().toISOString()}
-
-metadata:
-  storyId: "${storyId}"
-  specPath: "${specPath || 'N/A'}"
-  status: draft
-  createdAt: "${new Date().toISOString()}"
-
-phases:
-  - phase: 1
-    name: Setup
-    subtasks:
-      - id: "1.1"
-        name: Initialize project structure
-        status: pending
-
-  - phase: 2
-    name: Implementation
-    subtasks:
-      - id: "2.1"
-        name: Implement core functionality
-        status: pending
-
-  - phase: 3
-    name: Testing
-    subtasks:
-      - id: "3.1"
-        name: Write tests
-        status: pending
-
-  - phase: 4
-    name: Documentation
-    subtasks:
-      - id: "4.1"
-        name: Update documentation
-        status: pending
-`;
+    const now = new Date().toISOString();
+
+    // Build the plan as an object and serialize via yaml.dump. This is robust to
+    // any content — notably Windows absolute paths in `specPath`
+    // (e.g. "C:\Users\...\AppData\...") which, when hand-written into a
+    // double-quoted YAML scalar, contain invalid escape sequences (`\U`, `\A`)
+    // that make `yaml.load` throw and kill the whole build path on Windows.
+    // yaml.dump escapes/quotes correctly for any value (Story: FIX windows-path-yaml-plan).
+    const planObject = {
+      metadata: {
+        storyId,
+        specPath: specPath || 'N/A',
+        status: 'draft',
+        createdAt: now,
+      },
+      phases: [
+        {
+          phase: 1,
+          name: 'Setup',
+          subtasks: [{ id: '1.1', name: 'Initialize project structure', status: 'pending' }],
+        },
+        {
+          phase: 2,
+          name: 'Implementation',
+          subtasks: [{ id: '2.1', name: 'Implement core functionality', status: 'pending' }],
+        },
+        {
+          phase: 3,
+          name: 'Testing',
+          subtasks: [{ id: '3.1', name: 'Write tests', status: 'pending' }],
+        },
+        {
+          phase: 4,
+          name: 'Documentation',
+          subtasks: [{ id: '4.1', name: 'Update documentation', status: 'pending' }],
+        },
+      ],
+    };
+
+    const header = `# Implementation Plan: ${storyId}\n# Generated: ${now}\n\n`;
+    const stubPlan = header + yaml.dump(planObject, { lineWidth: -1, noRefs: true });
 
     await fs.ensureDir(path.dirname(planPath));
     await fs.writeFile(planPath, stubPlan);

package/.sinapse-ai/core/orchestration/gate-evaluator.js

@@ -54,7 +54,9 @@ const DEFAULT_GATE_CONFIG = {
     blocking: true,
     requireTests: true,
     minTestCoverage: 0,
-    checks: ['plan_complete', 'implementation_exists', 'no_critical_errors'],
+    // F5 (epic: orchestration-consolidation): `plan_is_real` gives this gate teeth —
+    // a degraded/stub/absent/subtask-less plan is BLOCKED, not waved through.
+    checks: ['plan_complete', 'plan_is_real', 'implementation_exists', 'no_critical_errors'],
   },
 };
 
@@ -148,11 +150,7 @@ class GateEvaluator {
       const checks = await this._runGateChecks(fromEpic, toEpic, epicResult, gateConfig);
       result.checks = checks;
 
-      // Calculate score
-      const passedChecks = checks.filter((c) => c.passed).length;
-      result.score = checks.length > 0 ? (passedChecks / checks.length) * 5 : 5;
-
-      // Collect issues
+      // Collect issues from failed checks
       result.issues = checks
         .filter((c) => !c.passed)
         .map((c) => ({
@@ -161,6 +159,22 @@ class GateEvaluator {
           severity: c.severity || 'medium',
         }));
 
+      // Calculate score — honesty invariant (F5, epic: orchestration-consolidation):
+      // a gate that evaluated ZERO checks verified NOTHING. It must NOT receive the
+      // max score (the old `: 5` was theater — an unconfigured gate always passed).
+      // Score 0 + an explicit issue so the verdict reflects "no real verification".
+      if (checks.length === 0) {
+        result.score = 0;
+        result.issues.push({
+          check: 'no_checks_evaluated',
+          message: 'Gate evaluated zero checks — nothing was actually verified',
+          severity: this.strictMode ? 'critical' : 'high',
+        });
+      } else {
+        const passedChecks = checks.filter((c) => c.passed).length;
+        result.score = (passedChecks / checks.length) * 5;
+      }
+
       // Determine verdict (AC2)
       result.verdict = this._determineVerdict(result, gateConfig);
 
@@ -188,6 +202,22 @@ class GateEvaluator {
   async _runGateChecks(fromEpic, toEpic, epicResult, gateConfig) {
     const checks = [];
 
+    // Universal honesty guard (master/gate leak fix, epic: orchestration-consolidation):
+    // a gate must NEVER approve a result that itself signals failure. The e2e checkpoint
+    // caught the gate approving (score 5.0) a QA report whose verdict was BLOCKED, because
+    // the existence checks (qa_report_exists / verdict_generated) never inspected the VALUE.
+    // This runs on EVERY gate, but ONLY adds a (failing, critical) check when a real failure
+    // signal is present — so it never inflates an honest zero-check gate (F5 invariant).
+    const failureSignal = this._detectFailureSignal(epicResult);
+    if (failureSignal) {
+      checks.push({
+        name: 'result_not_failed',
+        passed: false,
+        message: failureSignal,
+        severity: 'critical',
+      });
+    }
+
     // Get check list for this gate
     const checkNames = gateConfig.checks || this._getDefaultChecks(fromEpic, toEpic);
 
@@ -240,6 +270,36 @@ class GateEvaluator {
     return checks;
   }
 
+  /**
+   * Detect whether an epic result itself signals failure (master/gate leak fix).
+   *
+   * Returns a human-readable reason string when the result is NOT sound, or null when
+   * no failure signal is present. Used by `_runGateChecks` to add a critical, blocking
+   * check so a gate can never APPROVE a failed/blocked upstream result.
+   *
+   * @param {Object} epicResult - Result from the source epic
+   * @returns {string|null} Failure reason, or null if the result shows no failure signal
+   * @private
+   */
+  _detectFailureSignal(epicResult) {
+    if (!epicResult || typeof epicResult !== 'object') {
+      return null;
+    }
+    if (epicResult.success === false || epicResult.status === 'failed') {
+      return 'Epic result signals failure (success:false / status:failed)';
+    }
+    const norm = (v) => (typeof v === 'string' ? v.toLowerCase() : null);
+    const verdict = norm(epicResult.verdict);
+    if (verdict === 'blocked' || verdict === 'failed') {
+      return `Epic verdict is "${epicResult.verdict}"`;
+    }
+    const qaVerdict = epicResult.qaReport ? norm(epicResult.qaReport.verdict) : null;
+    if (qaVerdict === 'blocked' || qaVerdict === 'failed') {
+      return `QA report verdict is "${epicResult.qaReport.verdict}"`;
+    }
+    return null;
+  }
+
   /**
    * Run a single check
    * @private
@@ -279,11 +339,46 @@ class GateEvaluator {
         break;
 
       // Epic 4 checks
-      case 'plan_complete':
-        result.passed = !!epicResult.planPath || epicResult.planComplete === true;
+      case 'plan_complete': {
+        // F5: hardened but backward-compatible. When a real plan OBJECT is present
+        // (wired in via epic-4-executor), require real phases. When only a path/flag
+        // is present (legacy callers), keep the old signal so existing behavior holds.
+        const plan = epicResult.plan;
+        if (plan && typeof plan === 'object') {
+          result.passed = Array.isArray(plan.phases) && plan.phases.length > 0;
+        } else {
+          result.passed = !!epicResult.planPath || epicResult.planComplete === true;
+        }
         result.message = result.passed ? 'Implementation plan complete' : 'Plan not complete';
         result.severity = 'high';
         break;
+      }
+
+      case 'plan_is_real': {
+        // F5 (epic: orchestration-consolidation) — the gate's teeth. Honesty
+        // invariant: a degraded/stub/absent/subtask-less plan is NOT a real artifact
+        // and MUST block, not slip through. Critical severity → verdict BLOCKED.
+        const plan = epicResult.plan;
+        if (!plan || typeof plan !== 'object') {
+          result.passed = false;
+          result.message = 'No real plan object to inspect (plan absent)';
+        } else if (plan.degraded === true || plan.stub === true) {
+          result.passed = false;
+          result.message = `Plan is degraded/stub${plan.reason ? ` (${plan.reason})` : ''}`;
+        } else {
+          const phases = Array.isArray(plan.phases) ? plan.phases : [];
+          const subtaskCount = phases.reduce(
+            (n, p) => n + (Array.isArray(p.subtasks) ? p.subtasks.length : 0),
+            0,
+          );
+          result.passed = phases.length > 0 && subtaskCount > 0;
+          result.message = result.passed
+            ? `Plan is real (${phases.length} phase(s), ${subtaskCount} subtask(s))`
+            : 'Plan has no subtasks';
+        }
+        result.severity = 'critical';
+        break;
+      }
 
       case 'implementation_exists':
         result.passed = !!epicResult.implementationPath || epicResult.codeChanges?.length > 0;
@@ -342,7 +437,7 @@ class GateEvaluator {
       case 3:
         return ['spec_exists', 'complexity_assessed'];
       case 4:
-        return ['plan_complete', 'no_critical_errors'];
+        return ['plan_complete', 'plan_is_real', 'no_critical_errors'];
       case 6:
         return ['qa_report_exists', 'verdict_generated'];
       default:

package/.sinapse-ai/core/orchestration/greenfield-handler.js

@@ -624,62 +624,30 @@ class GreenfieldHandler extends EventEmitter {
   // ═══════════════════════════════════════════════════════════════════════════════════
 
   /**
-   * Spawns an agent via TerminalSpawner (AC7) with ExecutorAssignment (AC6)
+   * Resolves agent execution to an honest manual hand-off (AC6 selection only).
+   *
+   * The legacy visual-terminal lineage (TerminalSpawner → pm.sh) was a verified stub that
+   * never invoked claude, so spawning it fabricated success in headless-with-bash. It has
+   * been removed (STORY-F3C); execution is now handed off honestly to the user. Routing to
+   * the canonical `dispatcher → claude` lineage is intentionally out of scope here.
    *
    * @param {string} agent - Agent ID (e.g., '@devops')
    * @param {string} task - Task to execute
    * @param {Object} spawnContext - Spawn context
-   * @returns {Promise<Object>} Spawn result
+   * @returns {Promise<Object>} Honest manual hand-off result
    * @private
    */
   async _spawnAgent(agent, task, spawnContext = {}) {
-    this._log(`Spawning ${agent} for ${task}`);
+    this._log(`Handing off ${agent} for ${task} (manual execution)`);
 
     this.emit('agentSpawn', { agent, task, context: spawnContext });
 
-    try {
-      // Try TerminalSpawner first (AC7)
-      const TerminalSpawner = require('./terminal-spawner');
-
-      if (TerminalSpawner.isSpawnerAvailable()) {
-        const agentId = agent.replace('@', '');
-        const result = await TerminalSpawner.spawnAgent(agentId, task, {
-          context: {
-            instructions: spawnContext.instructions || `Execute ${task}`,
-            creates: spawnContext.creates || [],
-            requires: spawnContext.requires || [],
-            metadata: spawnContext.previousResults || {},
-          },
-          timeout: 7200000, // 2 hours
-          debug: this.options.debug,
-        });
-
-        if (result.pid) {
-          this.emit('terminalSpawn', { agent, pid: result.pid, task });
-        }
-
-        return {
-          success: result.success !== false,
-          pid: result.pid,
-          output: result.output,
-          outputFile: result.outputFile,
-        };
-      }
-
-      // Fallback: Return instructions for manual execution
-      this._log(`TerminalSpawner not available, returning manual instructions for ${agent}`);
-      return {
-        success: true,
-        manual: true,
-        instructions: `Spawn ${agent} manually and execute: *${task}`,
-      };
-    } catch (error) {
-      this._log(`Failed to spawn ${agent}: ${error.message}`, 'error');
-      return {
-        success: false,
-        error: error.message,
-      };
-    }
+    // Honest hand-off: return instructions for manual execution (no fabricated success).
+    return {
+      success: true,
+      manual: true,
+      instructions: `Spawn ${agent} manually and execute: *${task}`,
+    };
   }
 
   // ═══════════════════════════════════════════════════════════════════════════════════

package/.sinapse-ai/core/orchestration/index.js

@@ -41,9 +41,6 @@ const cliCommands = require('./cli-commands');
 // Story 11.1: Executor Assignment (Projeto Bob)
 const ExecutorAssignment = require('./executor-assignment');
 
-// Story 11.2: Terminal Spawner (Projeto Bob)
-const TerminalSpawner = require('./terminal-spawner');
-
 // Story 11.3: Workflow Executor (Projeto Bob)
 const {
   WorkflowExecutor,
@@ -216,15 +213,6 @@ module.exports = {
   validateExecutorAssignment: ExecutorAssignment.validateExecutorAssignment,
   EXECUTOR_ASSIGNMENT_TABLE: ExecutorAssignment.EXECUTOR_ASSIGNMENT_TABLE,
 
-  // Story 11.2: Terminal Spawner (Projeto Bob)
-  TerminalSpawner,
-  spawnAgent: TerminalSpawner.spawnAgent,
-  createContextFile: TerminalSpawner.createContextFile,
-  pollForOutput: TerminalSpawner.pollForOutput,
-  isSpawnerAvailable: TerminalSpawner.isSpawnerAvailable,
-  getPlatform: TerminalSpawner.getPlatform,
-  cleanupOldFiles: TerminalSpawner.cleanupOldFiles,
-
   // Story 11.3: Workflow Executor (Projeto Bob)
   WorkflowExecutor,
   createWorkflowExecutor,

package/.sinapse-ai/core/orchestration/master-orchestrator.js

@@ -478,10 +478,15 @@ class MasterOrchestrator extends EventEmitter {
           } else {
             pipelineResult.epicsFailed.push(epicNum);
 
-            // In strict mode or if epic is critical, stop pipeline
+            // Honesty invariant (master/gate leak fix): ANY failed epic means the
+            // pipeline did not fully succeed — not only critical/strict ones. A
+            // non-critical failure (e.g. QA/Epic 6) must still flip success:false so
+            // finalize() never reports an overall green build over a red epic.
+            pipelineResult.success = false;
+
+            // In strict mode or if epic is critical, also STOP the pipeline now.
             if (this.strictGates || this._isEpicCritical(epicNum)) {
               this._log(`Critical epic ${epicNum} failed, halting pipeline`);
-              pipelineResult.success = false;
               break;
             }
           }
@@ -604,6 +609,45 @@ class MasterOrchestrator extends EventEmitter {
         orchestrator: this,
       });
 
+      // Honesty invariant (epic: orchestration-consolidation — master/gate leak fix):
+      // an executor may signal failure by RETURNING { success:false } / { status:'failed' }
+      // WITHOUT throwing. The old code fell straight through to "mark COMPLETED" + logged
+      // "completed successfully" + returned { success:true } for any non-stub result — so a
+      // failed epic leaked a green pipeline (the e2e "Epic 4 failed" → "Epic 4 completed
+      // successfully" → exit 0 symptom). The `catch` below only handles THROWN errors, so a
+      // returned failure must be detected explicitly here and treated as a real failure.
+      const isStubResult = result && result.status === 'stub';
+      const isFailedResult =
+        result && !isStubResult && (result.success === false || result.status === 'failed');
+
+      if (isFailedResult) {
+        this.executionState.epics[epicNum] = {
+          ...this.executionState.epics[epicNum],
+          status: EpicStatus.FAILED,
+          completedAt: new Date().toISOString(),
+          result,
+          errors: [
+            ...(this.executionState.epics[epicNum]?.errors || []),
+            {
+              message: result.error || `Epic ${epicNum} returned a non-success result`,
+              timestamp: new Date().toISOString(),
+            },
+          ],
+        };
+
+        await this._saveState();
+
+        this.emit('epicComplete', { epicNum, result, gateResult: null });
+        this.onEpicComplete(epicNum, result);
+
+        this._log(`Epic ${epicNum} failed (executor returned non-success result)`, {
+          level: 'error',
+          icon: '❌',
+        });
+
+        return { success: false, status: 'failed', epicNum, result };
+      }
+
       // Mark as completed
       this.executionState.epics[epicNum] = {
         ...this.executionState.epics[epicNum],
@@ -614,8 +658,8 @@ class MasterOrchestrator extends EventEmitter {
 
       // Evaluate quality gate (Story 0.6) - only in full pipeline mode
       // Skip gate evaluation if result is from stub executor
+      // (isStubResult already computed above with the failure-detection guard).
       let gateResult = null;
-      const isStubResult = result && result.status === 'stub';
       if (this._inFullPipeline && result && result.success !== false && !isStubResult) {
         gateResult = await this._evaluateGate(epicNum, result);
 
@@ -1486,13 +1530,25 @@ class MasterOrchestrator extends EventEmitter {
     const seconds = Math.floor((duration % 60000) / 1000);
 
     const hasStubs = pipelineResult.hasStubs || (pipelineResult.epicsStubbed || []).length > 0;
+    // Honesty invariant (master/gate leak fix): a pipeline with ANY failed epic, or a
+    // final state of BLOCKED/FAILED, can never report success:true — even if a stale
+    // optimistic flag survived. `blocked` is surfaced so the CLI shows BLOCKED (exit 2)
+    // instead of "ORCHESTRATION COMPLETE" / exit 0.
+    const hasFailures = (pipelineResult.epicsFailed || []).length > 0;
+    const blocked = this._state === OrchestratorState.BLOCKED;
     return {
       workflowId: this.executionState.workflowId,
       storyId: this.storyId,
       status: this._state,
+      blocked,
       // Honesty invariant (epic: orchestration-consolidation, F0a): a pipeline that ran
       // any epic in STUB mode did NOT really build anything — it must not report success:true.
-      success: (pipelineResult.success ?? this._state === OrchestratorState.COMPLETE) && !hasStubs,
+      // A failed epic or a non-COMPLETE terminal state is likewise never a success.
+      success:
+        (pipelineResult.success ?? this._state === OrchestratorState.COMPLETE) &&
+        !hasStubs &&
+        !hasFailures &&
+        !blocked,
       mode: hasStubs ? 'stub' : 'real',
       stubbedEpics: pipelineResult.epicsStubbed || [],
       ...(hasStubs

package/.sinapse-ai/core/orchestration/session-state.js

@@ -20,6 +20,23 @@ const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 
+// On Windows a concurrent reader / AV / Search indexer can hold a transient lock
+// that makes fs.rename throw EPERM/EBUSY where POSIX would succeed. A short
+// bounded retry clears virtually all of these so persistence degrades gracefully.
+const TRANSIENT_LOCK_CODES = new Set(['EPERM', 'EBUSY', 'EACCES', 'ENOTEMPTY']);
+async function renameWithRetry(oldPath, newPath, retries = 3, delayMs = 120) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fs.rename(oldPath, newPath);
+    } catch (err) {
+      if (!TRANSIENT_LOCK_CODES.has(err.code) || attempt >= retries) {
+        throw err;
+      }
+      await new Promise((resolve) => setTimeout(resolve, delayMs * (attempt + 1)));
+    }
+  }
+}
+
 // Constants
 const SESSION_STATE_VERSION = '1.2';
 const SESSION_STATE_FILENAME = '.session-state.yaml';
@@ -729,7 +746,7 @@ O que você quer fazer?
       for (const file of stateFiles) {
         const oldPath = path.join(this.legacyStatePath, file);
         const newPath = path.join(this.legacyStatePath, `${file}.migrated`);
-        await fs.rename(oldPath, newPath);
+        await renameWithRetry(oldPath, newPath);
       }
 
       if (this.options.debug) {
@@ -775,7 +792,7 @@ O que você quer fazer?
     if (await this.exists()) {
       // Archive instead of delete
       const archivePath = `${this.stateFilePath}.discarded.${Date.now()}`;
-      await fs.rename(this.stateFilePath, archivePath);
+      await renameWithRetry(this.stateFilePath, archivePath);
 
       if (this.options.debug) {
         console.log(`[SessionState] Session archived to: ${archivePath}`);