sinapse-ai 1.19.1 → 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/executors/epic-4-executor.js

@@ -113,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,
           });
@@ -144,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,

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

@@ -300,6 +300,69 @@ class GateEvaluator {
     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
@@ -380,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/install-manifest.yaml

@@ -7,7 +7,7 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.19.1
+version: 1.19.2
 generator: scripts/generate-install-manifest.js
 file_count: 1161
 files:
@@ -496,9 +496,9 @@ files:
     type: core
     size: 34059
   - path: core/execution/build-orchestrator.js
-    hash: sha256:ac8adfb8d5ef580641430735a7f351cf96d6bfe8608e8e45b92106ee0d412cb7
+    hash: sha256:6b1a213652493a7f453267d2f4f7937f5dac625cdfb95ca558747468922cb12f
     type: core
-    size: 39805
+    size: 41204
   - path: core/execution/build-state-manager.js
     hash: sha256:3b2fe56bf0e1a480f663a02afbb83c6d11cf89fb56815381c7ccafab948a63ae
     type: core
@@ -992,9 +992,9 @@ files:
     type: core
     size: 9463
   - path: core/orchestration/executors/epic-4-executor.js
-    hash: sha256:dbf091d97a91fa601268a9f61ba2b8d7f4ed9a42349123e02fc0898218069ead
+    hash: sha256:9aa50bd546d00d79e9ed2642377a66cdecef4f91c36440fde5ef617b18296226
     type: core
-    size: 10174
+    size: 11029
   - path: core/orchestration/executors/epic-5-executor.js
     hash: sha256:865224cd6cb1f80c1228e149349aea5c335440201c9047f849d2ec85b73d3f03
     type: core
@@ -1016,9 +1016,9 @@ files:
     type: core
     size: 10211
   - path: core/orchestration/gate-evaluator.js
-    hash: sha256:22ac74902559eed2d3a85733b84b6a5794998255a892d54319a5106e878aec46
+    hash: sha256:514c80ec7b305bf85d9816bca4ecdfc972faa84796a84794fef71d302a93f72b
     type: core
-    size: 20388
+    size: 23437
   - path: core/orchestration/greenfield-handler.js
     hash: sha256:330be2c76c3eb5a9a1f1c975837308802b8fc6fb871f9b584787ae4e2aa8fcb1
     type: core

package/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.19.2] — 2026-07-01 — 🔒 Honestidade do gate (build vazio não passa) + aposta medida
+
+> Patch. Atualização segura via `npx sinapse-ai update`. Fecha o último furo de honestidade do motor achado ao medir a aposta de orquestração multi-story.
+
+### Bug Fixes
+
+- **orchestration** — o gate `epic4_to_epic6` aprovava (score 5.0) um build que não escreveu **nenhum arquivo**: o check `implementation_exists` aceitava `implementationPath`, que o epic-4 setava para o caminho do **plano** (sempre existe). Agora o check exige arquivos de código **reais** (`codeChanges` + `filesModified`, excluindo o plano) e bloqueia build vazio; o epic-4 não usa mais o `implementationPath` enganoso e o `BuildOrchestrator` expõe `filesModified` de verdade. Estende a invariante de honestidade — build "sucedido" sem arquivos ≠ sucesso (#317).
+
+### Documentation
+
+- **epic** — fecha o épico `orchestration-consolidation` com o **veredito medido do checkpoint "matar ou dobrar"**: HÍBRIDO. Na medição multi-story, o modo nativo entregou 3/3 stories em 64s e 1 chamada, enquanto o motor entregou 1/3 em ~13,5min (a coordenação multi-story corrompeu o estado entre stories). O motor é assumido como **assistente de story isolada** (spec + plano reais); a orquestração autônoma multi-story vira **limitação documentada** (`KNOWN-LIMITATIONS.md`), não promessa. Docs públicos já eram honestos (#318).
+
 ## [1.19.1] — 2026-06-30 — 🔧 Motor honesto ponta-a-ponta + Windows-safe
 
 > Patch. Atualização segura via `npx sinapse-ai update`. Fecha 2 defeitos do motor expostos pelo checkpoint e2e do épico orchestration-consolidation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sinapse-ai",
-  "version": "1.19.1",
+  "version": "1.19.2",
   "description": "SINAPSE AI: Framework de orquestracao de IA — 17 squads, 172 agentes especializados",
   "bin": {
     "sinapse": "bin/sinapse.js",