sinapse-ai 1.20.1 → 1.22.0

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

@@ -14,6 +14,7 @@
 const fs = require('fs-extra');
 const path = require('path');
 const EpicExecutor = require('./epic-executor');
+const { classifyComplexity } = require('../spec-complexity');
 
 /**
  * Spec Pipeline phases
@@ -131,14 +132,26 @@ class Epic3Executor extends EpicExecutor {
       this._addArtifact('spec', specPath);
 
       // Collect complexity and requirements from phases
-      const complexity = phaseResults['assess-complexity']?.complexity || 'STANDARD';
+      const assess = phaseResults['assess-complexity'] || {};
+      const complexity = assess.complexity || 'STANDARD';
       const requirements = phaseResults['gather-requirements']?.requirements || [];
 
+      // M4 (AF-20260704 #9b): turn the COMPLEX≥16 rule from prose into a
+      // deterministic classification. Prefer the numeric dimension score when the
+      // assess phase provides one; otherwise fall back to the level string.
+      const classification = classifyComplexity(
+        typeof assess.score === 'number' ? assess.score : assess.dimensions || complexity,
+      );
+
       // Honesty invariant (epic: orchestration-consolidation, F0a):
       // if the spec was auto-stubbed (no real agent ran), report STUB, not success.
       const specResult = {
         specPath,
-        complexity,
+        complexity: classification.level,
+        complexityScore: classification.score,
+        requiresRevisionCycle: classification.requiresRevisionCycle,
+        requiresFullSpecPipeline: classification.requiresFullSpecPipeline,
+        specPipelinePhases: classification.phases,
         requirements,
         phases: Object.keys(phaseResults),
       };

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

@@ -193,12 +193,14 @@ class Epic4Executor extends EpicExecutor {
   async _executeViaBuildOrchestrator(storyId, context) {
     try {
       const { BuildOrchestrator } = require('../../execution/build-orchestrator');
+      // buildOptions is passed once, via build() — which already merges it over
+      // the constructor config ({...this.config, ...options}). Passing it in both
+      // places (AF-20260704 Lote B) was redundant, not wrong.
       const builder = new BuildOrchestrator({
         rootPath: this.projectRoot,
         useWorktree: false,
         autoMerge: false,
         runQA: false,
-        ...(context.buildOptions || {}),
       });
       return await builder.build(storyId, context.buildOptions || {});
     } catch (err) {

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

@@ -152,9 +152,63 @@ class GreenfieldHandler extends EventEmitter {
     // Phase progress tracking
     this.phaseProgress = {};
 
+    // Onda3-S2: cached read of workflow metadata (confirmation_required).
+    this._confirmationRequired = null;
+
     this._log('GreenfieldHandler initialized');
   }
 
+  /**
+   * Reads `metadata.confirmation_required` from the resolved workflow YAML.
+   * Onda3-S2 (AF-20260702 item 3.4): the field used to be decorative — no code
+   * consumed it. Now `false` turns go_pause surfaces into auto-GO; `true` or
+   * any read/parse failure preserves the safe default (pause for the human).
+   *
+   * @returns {boolean} true = pause between phases (default), false = auto-GO
+   */
+  getConfirmationRequired() {
+    if (this._confirmationRequired !== null) return this._confirmationRequired;
+    let required = true;
+    try {
+      const yaml = require('js-yaml');
+      const raw = fs.readFileSync(this.workflowPath, 'utf8');
+      const parsed = yaml.load(raw);
+      if (parsed && parsed.metadata && parsed.metadata.confirmation_required === false) {
+        required = false;
+      }
+    } catch (error) {
+      this._log(`confirmation_required unreadable (default: true): ${error.message}`, 'warn');
+    }
+    this._confirmationRequired = required;
+    return required;
+  }
+
+  /**
+   * Deterministic artifact gate (Onda3-S2, AF-20260702 item 3.4).
+   * For every step that declares a file artifact (`creates` ending in .md),
+   * verifies the artifact exists on disk with content. Echoes the empty-build
+   * honesty fix: a phase does not advance on promises, only on artifacts.
+   *
+   * @param {Array<{agent: string, task: string, creates: ?string}>} sequence
+   * @returns {{passed: boolean, missing: Array<{agent: string, task: string, artifact: string}>, checked: number}}
+   */
+  evaluateArtifactGate(sequence) {
+    // Lazy require: doc-first-resolver imports constants from this module, so a
+    // top-level require here would create a load-order cycle with partial exports.
+    const { fileHasContent } = require('./doc-first-resolver');
+    const missing = [];
+    let checked = 0;
+    for (const step of sequence) {
+      if (!step.creates || !step.creates.endsWith('.md')) continue;
+      checked += 1;
+      const artifactPath = path.join(this.projectRoot, step.creates);
+      if (!fileHasContent(artifactPath)) {
+        missing.push({ agent: step.agent, task: step.task, artifact: step.creates });
+      }
+    }
+    return { passed: missing.length === 0, missing, checked };
+  }
+
   // ═══════════════════════════════════════════════════════════════════════════════════
   //                              LAZY DEPENDENCY LOADING
   // ═══════════════════════════════════════════════════════════════════════════════════
@@ -453,10 +507,45 @@ class GreenfieldHandler extends EventEmitter {
       }
     }
 
+    // Onda3-S2: deterministic artifact gate — the phase only completes when
+    // every declared artifact actually exists with content on disk.
+    const gate = this.evaluateArtifactGate(PHASE_1_SEQUENCE);
+    if (!gate.passed) {
+      this.phaseProgress[GreenfieldPhase.DISCOVERY] = {
+        status: 'gated',
+        endTime: Date.now(),
+        stepResults,
+        gate,
+      };
+      this.emit('phaseGated', { phase: GreenfieldPhase.DISCOVERY, gate, context });
+
+      const missingList = gate.missing
+        .map((m) => `  - ${m.artifact} (${m.agent} → *${m.task})`)
+        .join('\n');
+      return {
+        action: 'greenfield_gate_blocked',
+        phase: GreenfieldPhase.DISCOVERY,
+        nextPhase: 1,
+        data: {
+          gate: 'missing_artifact',
+          missing: gate.missing,
+          message:
+            'Gate de artefato: a Phase 1 não avança sem os artefatos no disco.\n' +
+            `Faltando:\n${missingList}\n\n` +
+            'Execute os agentes indicados (ou crie os documentos) e responda GO para revalidar.',
+          promptType: 'go_pause',
+          options: ['GO', 'PAUSE'],
+          resumeFromPhase: 1,
+          context: { ...context, phase1Results: stepResults },
+        },
+      };
+    }
+
     this.phaseProgress[GreenfieldPhase.DISCOVERY] = {
       status: 'complete',
       endTime: Date.now(),
       stepResults,
+      gate,
     };
 
     this.emit('phaseComplete', { phase: GreenfieldPhase.DISCOVERY, result: stepResults, context });
@@ -667,6 +756,14 @@ class GreenfieldHandler extends EventEmitter {
    * @private
    */
   _surfaceBetweenPhases(fromPhase, toPhase, surfaceConfig) {
+    // Onda3-S2: honor metadata.confirmation_required from the workflow YAML.
+    // Only go_pause surfaces auto-advance — text_input needs the human's words,
+    // and gate blocks never route through here.
+    if (surfaceConfig.promptType === 'go_pause' && this.getConfirmationRequired() === false) {
+      this._log(`confirmation_required=false — auto-GO Phase ${fromPhase} → ${toPhase}`);
+      return this._executeFromPhase(toPhase, surfaceConfig.context);
+    }
+
     const surfaceChecker = this._getSurfaceChecker();
 
     // Build options based on prompt type

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

@@ -158,6 +158,8 @@ const {
 
 module.exports = {
   // Main orchestrators
+  // @deprecated WorkflowOrchestrator has no internal consumers (AF-20260704);
+  // kept exported because the barrel is public package API. Prefer MasterOrchestrator.
   WorkflowOrchestrator,
   MasterOrchestrator, // Epic 0: ADE Master Orchestrator
 
@@ -290,6 +292,9 @@ module.exports = {
   STALE_SNAPSHOT_DAYS,
 
   // Story 12.4: Epic Context Accumulator (Projeto Bob)
+  // @deprecated EpicContextAccumulator has no internal consumers (AF-20260704;
+  // multi-story orchestration was measured and rejected — see KNOWN-LIMITATIONS.md).
+  // Kept exported because the barrel is public package API.
   EpicContextAccumulator,
   createEpicContextAccumulator,
   CompressionLevel,

package/.sinapse-ai/core/orchestration/spec-complexity.js

@@ -0,0 +1,141 @@
+/**
+ * Spec-Pipeline Complexity — deterministic threshold + phase plan.
+ *
+ * The COMPLEX≥16 rule lived only in prose (`workflow-execution.md` §3,
+ * `documentation-first.md` complexity gate): "score ≥16 → COMPLEX → run the full
+ * Spec Pipeline (6 phases + revision cycle) FIRST". Nothing in code enforced the
+ * threshold or derived the phase plan from it, so the assessment was advisory.
+ *
+ * This module turns the threshold and the per-level phase plan into deterministic,
+ * tested code (Story rodada2-m4, AF-20260704 #9b). It does NOT invent HOW the five
+ * dimensions are scored — those values come from the `assess-complexity` phase; it
+ * only encodes the mapping score → level → required phases, canonically defined in
+ * `workflow-execution.md`.
+ *
+ * @module core/orchestration/spec-complexity
+ */
+
+'use strict';
+
+/** The five complexity dimensions, each scored 1-5 (min 5, max 25). */
+const DIMENSIONS = Object.freeze(['scope', 'integration', 'infrastructure', 'knowledge', 'risk']);
+
+/**
+ * Canonical thresholds (`workflow-execution.md` §3):
+ *   score <= 8  → SIMPLE
+ *   9..15       → STANDARD
+ *   score >= 16 → COMPLEX
+ */
+const THRESHOLDS = Object.freeze({ SIMPLE_MAX: 8, COMPLEX_MIN: 16 });
+
+const LEVELS = Object.freeze({ SIMPLE: 'SIMPLE', STANDARD: 'STANDARD', COMPLEX: 'COMPLEX' });
+
+/**
+ * Phase plans per level (`workflow-execution.md` §3 table):
+ *   SIMPLE   → gather → spec → critique                                   (3)
+ *   STANDARD → gather → assess → research → spec → critique → plan        (6)
+ *   COMPLEX  → the 6 phases + a revision cycle                            (6 + revision)
+ */
+const PHASES_BY_LEVEL = Object.freeze({
+  SIMPLE: Object.freeze(['gather-requirements', 'write-spec', 'critique']),
+  STANDARD: Object.freeze([
+    'gather-requirements',
+    'assess-complexity',
+    'research-dependencies',
+    'write-spec',
+    'critique',
+    'plan',
+  ]),
+  COMPLEX: Object.freeze([
+    'gather-requirements',
+    'assess-complexity',
+    'research-dependencies',
+    'write-spec',
+    'critique',
+    'plan',
+  ]),
+});
+
+/**
+ * Map a numeric complexity score to its level. Deterministic; no side effects.
+ * @param {number} score - Sum of the five dimensions (nominally 5..25).
+ * @returns {'SIMPLE'|'STANDARD'|'COMPLEX'}
+ */
+function scoreToLevel(score) {
+  const n = Number(score);
+  if (!Number.isFinite(n)) return LEVELS.STANDARD; // conservative default
+  if (n <= THRESHOLDS.SIMPLE_MAX) return LEVELS.SIMPLE;
+  if (n >= THRESHOLDS.COMPLEX_MIN) return LEVELS.COMPLEX;
+  return LEVELS.STANDARD;
+}
+
+/** Normalize a level-ish input (a level string, in any case) to a canonical level. */
+function normalizeLevel(level) {
+  const u = String(level || '').trim().toUpperCase();
+  return LEVELS[u] || null;
+}
+
+/**
+ * Sum an object of dimension → score (1-5). Missing dimensions count as 0.
+ * @param {Record<string, number>} dimensions
+ * @returns {number}
+ */
+function sumDimensions(dimensions) {
+  if (!dimensions || typeof dimensions !== 'object') return NaN;
+  return DIMENSIONS.reduce((total, d) => {
+    const v = Number(dimensions[d]);
+    return total + (Number.isFinite(v) ? v : 0);
+  }, 0);
+}
+
+/**
+ * Classify complexity from either a numeric score, a dimensions object, or an
+ * already-decided level string. Returns the deterministic plan.
+ *
+ * @param {number|string|Record<string, number>} input
+ * @returns {{
+ *   level: 'SIMPLE'|'STANDARD'|'COMPLEX',
+ *   score: number|null,
+ *   phases: string[],
+ *   requiresRevisionCycle: boolean,
+ *   requiresFullSpecPipeline: boolean
+ * }}
+ */
+function classifyComplexity(input) {
+  let level;
+  let score = null;
+
+  if (typeof input === 'number') {
+    score = input;
+    level = scoreToLevel(input);
+  } else if (typeof input === 'string') {
+    level = normalizeLevel(input) || LEVELS.STANDARD;
+  } else if (input && typeof input === 'object') {
+    const s = sumDimensions(input);
+    score = Number.isFinite(s) ? s : null;
+    level = Number.isFinite(s) ? scoreToLevel(s) : LEVELS.STANDARD;
+  } else {
+    level = LEVELS.STANDARD; // conservative default when nothing usable is given
+  }
+
+  return {
+    level,
+    score,
+    phases: [...PHASES_BY_LEVEL[level]],
+    // COMPLEX is the only level that adds the revision cycle.
+    requiresRevisionCycle: level === LEVELS.COMPLEX,
+    // SIMPLE runs the trimmed 3-phase pipeline; STANDARD/COMPLEX run the full one.
+    requiresFullSpecPipeline: level !== LEVELS.SIMPLE,
+  };
+}
+
+module.exports = {
+  DIMENSIONS,
+  THRESHOLDS,
+  LEVELS,
+  PHASES_BY_LEVEL,
+  scoreToLevel,
+  normalizeLevel,
+  sumDimensions,
+  classifyComplexity,
+};

package/.sinapse-ai/core/orchestration/workflow-executor.js

@@ -474,7 +474,7 @@ class WorkflowExecutor {
       return { success: false, error: `Workflow definition is empty: ${workflowPath}` };
     }
 
-    return {
+    const result = {
       success: true,
       workflowPath,
       workflow,
@@ -484,6 +484,22 @@ class WorkflowExecutor {
         techStack: options.techStack || {},
       },
     };
+
+    // Onda3-S3 (AF-20260702 item 3.3): the brownfield handoff now carries
+    // deterministic state — phase progress measured from artifacts on disk and
+    // the Phase 7 QA gate parsed by code (with capped rework loop). Fail-open:
+    // enrichment errors degrade to the plain handoff, never to a crash.
+    if (workflow.id === 'brownfield-discovery') {
+      try {
+        const { resolveBrownfieldProgress, evaluateQaGate } = require('./brownfield-progress');
+        result.progress = resolveBrownfieldProgress(result.context.projectRoot, workflow);
+        result.qaGate = evaluateQaGate(result.context.projectRoot);
+      } catch (error) {
+        result.progressError = `brownfield progress unavailable: ${error.message}`;
+      }
+    }
+
+    return result;
   }
 
   /**

package/.sinapse-ai/core-config.yaml

@@ -193,6 +193,12 @@ github:
     draft_by_default: false
   semantic_release:
     enabled: true
+# ── CodeRabbit integration — SINGLE SOURCE OF TRUTH ──────────────────────────
+# This section (machine config) + .claude/rules/coderabbit-integration.md
+# (auto-loaded, human-readable) are the ONE canonical source for WSL execution
+# mechanics, self-healing thresholds, canonical review commands and report
+# location. Agents REFERENCE this — they must NOT copy the mechanics into their
+# own definitions. (Dedup: Story rodada2-m6-coderabbit-dedup.)
 coderabbit_integration:
   enabled: true
   installation_mode: wsl
@@ -213,11 +219,35 @@ coderabbit_integration:
   graceful_degradation:
     skip_if_not_installed: true
     fallback_message: 'CodeRabbit CLI not found. Skipping automated review. Install via: pip install coderabbit-cli'
+  # Canonical review commands (referenced by all agents; keyed by intent, not by agent).
   commands:
+    review_uncommitted: |
+      wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only -t uncommitted'
+    review_committed_base_main: |
+      wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only -t committed --base main'
+    review_against_main: |
+      wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only --base main'
+    review_committed: |
+      wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only -t committed'
+    # Back-compat aliases (previous key names):
     qa_pre_review_uncommitted: |
       wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only -t uncommitted'
     qa_story_review_committed: |
       wsl bash -c 'cd ${PROJECT_ROOT} && ~/.local/bin/coderabbit --prompt-only -t committed --base main'
+  execution_guidelines: |
+    CRITICAL: CodeRabbit CLI is installed in WSL, not Windows.
+
+    **How to Execute:**
+    1. Use 'wsl bash -c' wrapper for all commands
+    2. Navigate to project directory in WSL path format (/mnt/c/...)
+    3. Use full path to coderabbit binary (~/.local/bin/coderabbit)
+
+    **Timeout:** dev/pre-push 15 min (900000ms); full QA review 30 min (1800000ms) — reviews take 7-30 min.
+
+    **Error Handling:**
+    - If "coderabbit: command not found" → verify installation in WSL (wsl_config.installation_path)
+    - If timeout → increase timeout, review is still processing
+    - If "not authenticated" → user needs to run: wsl bash -c '~/.local/bin/coderabbit auth status'
   report_location: docs/qa/coderabbit-reports/
 squads:
   templateLocation: templates/squad