sinapse-ai 1.19.0 → 1.19.2

package/.sinapse-ai/core/execution/build-orchestrator.js

@@ -231,6 +231,11 @@ class BuildOrchestrator extends EventEmitter {
         // quality gate can inspect its honesty (degraded/stub/subtasks). Without this
         // the epic4_to_epic6 gate has nothing real to bite on.
         plan: ctx.plan,
+        // epic: empty-build-honesty — surface the REAL files the build wrote/modified
+        // (collected from the build loop's per-subtask results). Without this the
+        // downstream `implementation_exists` gate cannot tell a real build apart from
+        // an empty "success" that touched zero code files.
+        filesModified: this._collectModifiedFiles(ctx),
       };
     } catch (error) {
       ctx.errors.push(error);
@@ -263,6 +268,32 @@ class BuildOrchestrator extends EventEmitter {
     }
   }
 
+  /**
+   * Collect the real files the build wrote/modified from the build-loop result.
+   *
+   * epic: empty-build-honesty — the per-subtask results carry `filesModified`
+   * (extracted from the agent output). This flattens + de-duplicates them into a
+   * single honest list. Returns [] when nothing was touched (an empty build), which
+   * is precisely the signal the `implementation_exists` gate needs to block.
+   *
+   * @param {Object} ctx - Build context ({ result: { results: [...] } })
+   * @returns {string[]} De-duplicated list of modified files
+   * @private
+   */
+  _collectModifiedFiles(ctx) {
+    const results = ctx && ctx.result && Array.isArray(ctx.result.results) ? ctx.result.results : [];
+    const files = [];
+    for (const r of results) {
+      const list = r && Array.isArray(r.filesModified) ? r.filesModified : [];
+      for (const f of list) {
+        if (typeof f === 'string' && f.trim() !== '' && !files.includes(f)) {
+          files.push(f);
+        }
+      }
+    }
+    return files;
+  }
+
   /**
    * Run a phase with event emission and error handling
    */

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

@@ -10,8 +10,7 @@
  *
  * Integrates all Epic 11 modules:
  * - ExecutorAssignment (11.1) — agent selection
- * - TerminalSpawner (11.2) — agent spawning
- * - WorkflowExecutor (11.3) — development cycle
+ * - WorkflowExecutor (11.3) — development cycle (honest manual hand-off)
  * - SurfaceChecker (11.4) — human decision criteria
  * - SessionState (11.5) — session persistence
  *
@@ -1252,8 +1251,7 @@ class BobOrchestrator {
    *
    * Delegates to Epic 11 modules:
    * - ExecutorAssignment for agent selection (AC8)
-   * - TerminalSpawner for agent spawning (AC9)
-   * - WorkflowExecutor for development cycle (AC10)
+   * - WorkflowExecutor for development cycle, with honest manual hand-off (AC10)
    *
    * Story 12.5 AC5: Updates session state at each phase transition.
    *

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');
 
 /**
@@ -112,13 +113,23 @@ class Epic4Executor extends EpicExecutor {
       if (this._realExecutionAllowed()) {
         const buildResult = await this._executeViaBuildOrchestrator(storyId, context);
         if (buildResult && buildResult.success) {
+          // Honesty invariant (epic: empty-build-honesty): do NOT set
+          // `implementationPath = planPath`. A plan path ALWAYS exists and is NOT
+          // proof of implementation — the multi-story measurement caught the gate
+          // approving an empty build because of exactly this. Surface the REAL files
+          // the build touched so the epic4_to_epic6 gate can tell an implementation
+          // apart from an empty "success".
+          const codeChanges = Array.isArray(buildResult.filesModified)
+            ? buildResult.filesModified
+            : [];
           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,
+            codeChanges,
+            filesModified: codeChanges,
             reportPath: buildResult.reportPath,
             phases: buildResult.phases,
           });
@@ -143,7 +154,10 @@ class Epic4Executor extends EpicExecutor {
       return this._stubExecution(
         'Epic 4 stub mode — real build is delegated to BuildOrchestrator outside the test runner',
         {
-          implementationPath: planPath,
+          // Honesty invariant (epic: empty-build-honesty): no `implementationPath`
+          // here — the plan path is not an implementation. The stub already reports
+          // success:false, and `codeChanges` carries whatever real files (if any)
+          // the subtasks touched.
           planPath,
           progress,
           subtaskResults,
@@ -215,44 +229,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

@@ -202,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);
 
@@ -254,6 +270,99 @@ 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;
+  }
+
+  /**
+   * Collect the REAL code files an epic actually wrote/modified.
+   *
+   * Honesty invariant (epic: empty-build-honesty): a plan file is NOT an
+   * implementation. This gathers the concrete files touched from `codeChanges` /
+   * `filesModified` (and `build.filesModified` when the build result is nested),
+   * then EXCLUDES the plan artifact (`planPath` / `implementationPath`) so a build
+   * that only produced a plan yields an empty list — and the caller can block it.
+   *
+   * Entries may be strings or `{ path | file }` objects; blanks and duplicates are
+   * dropped. Returns a de-duplicated array of file paths (never the plan itself).
+   *
+   * @param {Object} epicResult - Result from the source epic
+   * @returns {string[]} Real implementation files (plan artifact excluded)
+   * @private
+   */
+  _collectImplementationFiles(epicResult) {
+    if (!epicResult || typeof epicResult !== 'object') {
+      return [];
+    }
+
+    const resolveSafe = (p) => {
+      try {
+        return path.resolve(p);
+      } catch {
+        return null;
+      }
+    };
+
+    // The plan artifact is explicitly NOT an implementation — exclude it.
+    const planPaths = new Set(
+      [epicResult.planPath, epicResult.implementationPath]
+        .filter((p) => typeof p === 'string' && p.trim() !== '')
+        .map(resolveSafe)
+        .filter(Boolean),
+    );
+
+    const raw = []
+      .concat(Array.isArray(epicResult.codeChanges) ? epicResult.codeChanges : [])
+      .concat(Array.isArray(epicResult.filesModified) ? epicResult.filesModified : [])
+      .concat(
+        epicResult.build && Array.isArray(epicResult.build.filesModified)
+          ? epicResult.build.filesModified
+          : [],
+      );
+
+    const files = [];
+    for (const entry of raw) {
+      const file = typeof entry === 'string' ? entry : entry && (entry.path || entry.file);
+      if (typeof file !== 'string' || file.trim() === '') {
+        continue;
+      }
+      const resolved = resolveSafe(file);
+      if (resolved && planPaths.has(resolved)) {
+        continue; // a plan path masquerading as a code change — not implementation
+      }
+      if (!files.includes(file)) {
+        files.push(file);
+      }
+    }
+    return files;
+  }
+
   /**
    * Run a single check
    * @private
@@ -334,11 +443,23 @@ class GateEvaluator {
         break;
       }
 
-      case 'implementation_exists':
-        result.passed = !!epicResult.implementationPath || epicResult.codeChanges?.length > 0;
-        result.message = result.passed ? 'Implementation exists' : 'No implementation found';
+      case 'implementation_exists': {
+        // Honesty invariant (epic: empty-build-honesty): "implementation exists"
+        // MUST mean real code was written — not merely that a PLAN file exists. The
+        // multi-story measurement (2026-06-30) caught this gate APPROVING (score 5.0)
+        // a build that wrote ZERO code files: the old check trusted
+        // `implementationPath`, but epic-4 set that to the PLAN path (which ALWAYS
+        // exists), so an empty build slipped through. Base the check on the real list
+        // of files touched by the build, excluding the plan artifact itself. Empty
+        // build → zero real files → critical fail → gate BLOCKS (empty ≠ success).
+        const files = this._collectImplementationFiles(epicResult);
+        result.passed = files.length > 0;
+        result.message = result.passed
+          ? `Implementation exists (${files.length} code file(s) changed)`
+          : 'No implementation found — build wrote zero code files (plan path is not implementation)';
         result.severity = 'critical';
         break;
+      }
 
       case 'no_critical_errors': {
         const criticalErrors = (epicResult.errors || []).filter((e) => e.severity === 'critical');

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