sinapse-ai 1.6.1 → 1.8.0

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

@@ -85,6 +85,18 @@ const { G2StoryCreationGate } = require('./gates/g2-story-creation');
 const { G3StoryValidationGate } = require('./gates/g3-story-validation');
 const { G4DevContextGate, G4_DEFAULT_TIMEOUT_MS } = require('./gates/g4-dev-context');
 
+// IDS-5b: Gate G5 (Blocking — Semantic Handshake)
+const {
+  G5SemanticHandshakeGate,
+  G5_DEFAULT_TIMEOUT_MS,
+} = require('./gates/g5-semantic-handshake');
+
+// IDS Gate Wiring: Gate G6 (Blocking — CI/CD Registry Integrity)
+const {
+  G6CiIntegrityGate,
+  G6_DEFAULT_TIMEOUT_MS,
+} = require('./gates/g6-ci-integrity');
+
 // IDS-7: Framework Governor (sinapse-orqx integration)
 const {
   FrameworkGovernor,
@@ -92,6 +104,12 @@ const {
   RISK_THRESHOLDS,
 } = require('./framework-governor');
 
+// IDS Gate Wiring: Gate Evaluator (wires G1-G5 into the SDC workflow)
+const {
+  GateEvaluator,
+  DEFAULT_PHASE_GATES,
+} = require('./gate-evaluator');
+
 module.exports = {
   // IDS-1: Registry Foundation
   RegistryLoader,
@@ -149,9 +167,21 @@ module.exports = {
   G4DevContextGate,
   G4_DEFAULT_TIMEOUT_MS,
 
+  // IDS-5b: Gate G5 (Blocking)
+  G5SemanticHandshakeGate,
+  G5_DEFAULT_TIMEOUT_MS,
+
+  // IDS Gate Wiring: Gate G6 (Blocking — CI/CD Registry Integrity)
+  G6CiIntegrityGate,
+  G6_DEFAULT_TIMEOUT_MS,
+
   // IDS-7: Framework Governor
   FrameworkGovernor,
   TIMEOUT_MS,
   RISK_THRESHOLDS,
+
+  // IDS Gate Wiring: Gate Evaluator
+  GateEvaluator,
+  DEFAULT_PHASE_GATES,
 };
 

package/.sinapse-ai/core/memory/__tests__/active-modules.verify.js

@@ -7,6 +7,17 @@
  *
  * @created 2026-01-29
  * @updated 2026-02-09 - Removed orphan modules tests (Story MIS-2)
+ * @updated 2026-06-15 - Status note added (see below)
+ *
+ * STATUS — IMPORTANT (do not mistake this for a passing CI gate):
+ * This is a `.verify.js` standalone script (run manually via `node`), NOT a
+ * Jest spec — jest.config.js only matches `*.test.js`/`*.spec.js`, so it never
+ * runs in CI. The "Feedback Loop" section below asserts the Story 9.4 surface
+ * (FeedbackType enum + trackUserFeedback / getAccuracyMetrics / getSuggestedRules)
+ * which is NOT yet implemented in gotchas-memory.js — those assertions are a
+ * forward spec for pending work, not a regression check. The Custom Rules
+ * section reflects shipped behavior. Do not "fix" this by inventing the feedback
+ * feature without its story (Constitution Art. IV — No Invention).
  */
 
 const path = require('path');

package/.sinapse-ai/core/memory/gotchas-memory.js

@@ -253,15 +253,29 @@ class GotchasMemory extends EventEmitter {
         count: 0,
         firstSeen: now,
         lastSeen: now,
+        timestamps: [],
         samples: [],
         errorPattern: errorData.message,
         category: this._detectCategory(errorData.message + ' ' + (errorData.stack || '')),
       };
     }
 
-    // Update tracking
-    tracking.count++;
+    // Keep only occurrences inside the configured rolling error window.
+    const windowStart = now - this.options.errorWindowMs;
+    const timestamps = this._normalizeErrorTimestamps(tracking).filter(
+      (timestamp) => timestamp >= windowStart,
+    );
+    timestamps.push(now);
+
+    tracking.timestamps = timestamps;
+    tracking.count = timestamps.length;
+    tracking.firstSeen = timestamps[0];
     tracking.lastSeen = now;
+    tracking.samples = (tracking.samples || []).filter((sample) => {
+      const timestamp = Date.parse(sample.timestamp);
+      return Number.isFinite(timestamp) && timestamp >= windowStart;
+    });
+
     if (tracking.samples.length < 5) {
       tracking.samples.push({
         timestamp: new Date(now).toISOString(),
@@ -759,6 +773,27 @@ class GotchasMemory extends EventEmitter {
     return Math.abs(hash).toString(16);
   }
 
+  /**
+   * Normalize persisted error occurrence timestamps.
+   * Backward-compat: if tracking only has lastSeen (legacy format), fall back to [lastSeen].
+   * @private
+   * @param {Object} tracking - Error tracking entry
+   * @returns {number[]} Timestamp list in milliseconds
+   */
+  _normalizeErrorTimestamps(tracking) {
+    const timestamps = Array.isArray(tracking.timestamps) ? tracking.timestamps : [tracking.lastSeen];
+
+    return timestamps
+      .map((timestamp) => {
+        if (typeof timestamp === 'number') {
+          return timestamp;
+        }
+        const parsed = Date.parse(timestamp);
+        return Number.isFinite(parsed) ? parsed : null;
+      })
+      .filter((timestamp) => timestamp !== null);
+  }
+
   /**
    * Detect category from text
    * @private

package/.sinapse-ai/core/orchestration/agent-invoker.js

@@ -116,6 +116,12 @@ class AgentInvoker extends EventEmitter {
     // Audit log (AC7)
     this.invocations = [];
     this.logs = [];
+
+    // Memoization caches: agent/task definitions are read from disk on every
+    // invocation but never change during a process run. Caching avoids the
+    // repeated fs.readFile hops the deep-dive flagged as a redundant I/O hop.
+    this._agentCache = new Map();
+    this._taskCache = new Map();
   }
 
   /**
@@ -218,6 +224,10 @@ class AgentInvoker extends EventEmitter {
     // Normalize agent name (remove @ prefix if present)
     const name = agentName.replace(/^@/, '').toLowerCase();
 
+    if (this._agentCache.has(name)) {
+      return this._agentCache.get(name);
+    }
+
     // Check if supported
     const agentConfig = SUPPORTED_AGENTS[name];
     if (!agentConfig) {
@@ -239,12 +249,14 @@ class AgentInvoker extends EventEmitter {
 
     const content = await fs.readFile(agentPath, 'utf8');
 
-    return {
+    const result = {
       ...agentConfig,
       loaded: true,
       content,
       path: agentPath,
     };
+    this._agentCache.set(name, result);
+    return result;
   }
 
   /**
@@ -252,6 +264,10 @@ class AgentInvoker extends EventEmitter {
    * @private
    */
   async _loadTask(taskPath) {
+    if (this._taskCache.has(taskPath)) {
+      return this._taskCache.get(taskPath);
+    }
+
     // Handle both full path and task name
     let fullPath = taskPath;
     if (!path.isAbsolute(taskPath)) {
@@ -275,12 +291,14 @@ class AgentInvoker extends EventEmitter {
     // Parse task metadata from frontmatter
     const metadata = this._parseTaskMetadata(content);
 
-    return {
+    const result = {
       path: fullPath,
       name: path.basename(fullPath, '.md'),
       content,
       ...metadata,
     };
+    this._taskCache.set(taskPath, result);
+    return result;
   }
 
   /**
@@ -401,11 +419,16 @@ class AgentInvoker extends EventEmitter {
       );
     }
 
-    // Default: return simulated result
-    // In production, this would interface with Claude/LLM
+    // Honesty invariant (epic: orchestration-consolidation, F1):
+    // No executor wired → do NOT fabricate a 'simulated' success. Report a stub so
+    // callers never mistake "nothing ran" for real work. The MasterOrchestrator
+    // supplies a real SubagentDispatcher executor by default (_createDispatchExecutor).
     return {
-      status: 'simulated',
-      message: `Task ${task.name} executed by @${agent.name}`,
+      status: 'stub',
+      stub: true,
+      stubReason:
+        'No executor wired into AgentInvoker — real dispatch is supplied by MasterOrchestrator.',
+      message: `Task ${task.name} not executed (no executor) for @${agent.name}`,
       context: {
         agentName: agent.name,
         taskName: task.name,

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

@@ -67,6 +67,35 @@ const PhaseFailureAction = {
   ABORT: 'abort',
 };
 
+/**
+ * Maps a classified project_type to its brownfield workflow variant. Variants
+ * stay separate files (distinct contracts — fusion refuted in the deep-dive);
+ * the handler dispatches to the right one. Unknown/absent type falls back to
+ * brownfield-discovery (the generic 10-phase tech-debt assessment default).
+ * @see project-intelligence.md classification matrix
+ */
+const BROWNFIELD_WORKFLOW_BY_TYPE = Object.freeze({
+  site: 'brownfield-ui',
+  lp: 'brownfield-ui',
+  app: 'brownfield-ui',
+  platform: 'brownfield-fullstack',
+  saas: 'brownfield-fullstack',
+  api: 'brownfield-service',
+  service: 'brownfield-service',
+});
+
+const DEFAULT_BROWNFIELD_WORKFLOW = 'brownfield-discovery';
+
+/**
+ * Resolve the brownfield workflow basename for a project_type.
+ * @param {string} [projectType]
+ * @returns {string} workflow name (without extension)
+ */
+function resolveBrownfieldWorkflow(projectType) {
+  const key = String(projectType || '').toLowerCase();
+  return BROWNFIELD_WORKFLOW_BY_TYPE[key] || DEFAULT_BROWNFIELD_WORKFLOW;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════════
 //                              BROWNFIELD HANDLER CLASS
 // ═══════════════════════════════════════════════════════════════════════════════════
@@ -101,10 +130,12 @@ class BrownfieldHandler extends EventEmitter {
     this._surfaceChecker = options.surfaceChecker || null;
     this._sessionState = options.sessionState || null;
 
-    // Workflow path
+    // Workflow variant dispatched by project_type (site/lp/app → ui,
+    // platform/saas → fullstack, api/service → service). Default discovery.
+    this.workflowName = resolveBrownfieldWorkflow(options.projectType);
     this.workflowPath = path.join(
       projectRoot,
-      '.sinapse-ai/development/workflows/brownfield-discovery.yaml',
+      `.sinapse-ai/development/workflows/${this.workflowName}.yaml`,
     );
 
     // Phase progress tracking
@@ -723,7 +754,7 @@ Quer que eu comece?`;
       const exists = await sessionState.exists();
       if (exists) {
         await sessionState.loadSessionState();
-        await sessionState.recordPhaseChange(`brownfield_${phase}`, 'brownfield-discovery', '@architect');
+        await sessionState.recordPhaseChange(`brownfield_${phase}`, this.workflowName, '@architect');
         this._log(`Phase recorded in session state: ${phase}`);
       }
     } catch (error) {
@@ -758,5 +789,7 @@ module.exports = {
   BrownfieldPhase,
   PostDiscoveryChoice,
   PhaseFailureAction,
+  BROWNFIELD_WORKFLOW_BY_TYPE,
+  resolveBrownfieldWorkflow,
 };
 

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

@@ -23,6 +23,28 @@
  * @property {string} reason - Reason for the decision
  */
 
+/**
+ * Runtime-resolved condition defaults.
+ * These values are used when a condition is not a built-in evaluator and
+ * no runtime override has been set.  Frozen so callers cannot mutate them.
+ */
+const RUNTIME_CONDITION_DEFAULTS = Object.freeze({
+  after_prd_creation: true,
+  architecture_changes_needed: true,
+  architecture_suggests_prd_changes: true,
+  based_on_classification: true,
+  documentation_inadequate: true,
+  epic_complete: true,
+  gate_approved: true,
+  major_enhancement_path: true,
+  po_checklist_issues: true,
+  qa_left_unchecked_items: true,
+  stories_remaining: true,
+  user_has_generated_ui: true,
+  user_wants_ai_generation: true,
+  user_wants_story_review: true,
+});
+
 /**
  * Evaluates workflow conditions based on detected tech stack
  */
@@ -36,6 +58,30 @@ class ConditionEvaluator {
     // Context for QA approval tracking (updated externally)
     this._qaApproved = false;
     this._phaseOutputs = {};
+
+    // Runtime condition overrides — take precedence over defaults and built-ins
+    this._runtimeOverrides = new Map();
+  }
+
+  /**
+   * Set a single runtime-resolved condition value.
+   * Runtime overrides take precedence over RUNTIME_CONDITION_DEFAULTS and
+   * over built-in tech-stack evaluators.
+   * @param {string} name - Condition name
+   * @param {boolean} value - Runtime condition value
+   */
+  setRuntimeCondition(name, value) {
+    this._runtimeOverrides.set(name, Boolean(value));
+  }
+
+  /**
+   * Set multiple runtime-resolved condition values at once.
+   * @param {Object} overrides - Map of condition names to boolean values
+   */
+  setRuntimeConditions(overrides = {}) {
+    for (const [name, value] of Object.entries(overrides)) {
+      this.setRuntimeCondition(name, value);
+    }
   }
 
   /**
@@ -65,6 +111,11 @@ class ConditionEvaluator {
       return true;
     }
 
+    // Runtime overrides take highest precedence
+    if (this._runtimeOverrides.has(condition)) {
+      return this._runtimeOverrides.get(condition);
+    }
+
     // Built-in condition evaluators
     const evaluators = {
       // Tech stack conditions
@@ -105,6 +156,11 @@ class ConditionEvaluator {
       return evaluator();
     }
 
+    // Fall back to frozen defaults for known runtime conditions
+    if (Object.prototype.hasOwnProperty.call(RUNTIME_CONDITION_DEFAULTS, condition)) {
+      return RUNTIME_CONDITION_DEFAULTS[condition];
+    }
+
     // Handle negation first
     if (condition.startsWith('!')) {
       return !this.evaluate(condition.substring(1).trim());
@@ -377,4 +433,5 @@ class ConditionEvaluator {
 }
 
 module.exports = ConditionEvaluator;
+module.exports.RUNTIME_CONDITION_DEFAULTS = RUNTIME_CONDITION_DEFAULTS;
 

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

@@ -77,6 +77,7 @@ class Epic3Executor extends EpicExecutor {
       // Execute spec pipeline phases
       const phaseResults = {};
       let specPath = null;
+      let specWasStubbed = false;
 
       for (const phase of SPEC_PHASES) {
         this._log(`Running phase: ${phase}`);
@@ -113,9 +114,18 @@ class Epic3Executor extends EpicExecutor {
 
       // Check if spec file exists
       if (!(await fs.pathExists(specPath))) {
-        // Create stub spec for pipeline to continue
-        await this._createStubSpec(specPath, storyId, context);
-        this._log('Created stub spec (real spec generation requires agent invocation)');
+        // F1: try to generate a REAL spec via a real agent through the orchestrator.
+        const generated = await this._generateSpecViaAgent(storyId, source, techStack, context);
+        if (generated) {
+          await fs.ensureDir(path.dirname(specPath));
+          await fs.writeFile(specPath, generated);
+          this._log('Generated spec via real agent invocation');
+        } else {
+          // No executor wired (or agent produced nothing) → honest stub.
+          await this._createStubSpec(specPath, storyId, context);
+          this._log('Created stub spec (no real agent available)');
+          specWasStubbed = true;
+        }
       }
 
       this._addArtifact('spec', specPath);
@@ -124,12 +134,20 @@ class Epic3Executor extends EpicExecutor {
       const complexity = phaseResults['assess-complexity']?.complexity || 'STANDARD';
       const requirements = phaseResults['gather-requirements']?.requirements || [];
 
-      return this._completeExecution({
+      // Honesty invariant (epic: orchestration-consolidation, F0a):
+      // if the spec was auto-stubbed (no real agent ran), report STUB, not success.
+      const specResult = {
         specPath,
         complexity,
         requirements,
         phases: Object.keys(phaseResults),
-      });
+      };
+      return specWasStubbed
+        ? this._stubExecution(
+            'Spec auto-stubbed — real spec generation requires agent invocation',
+            specResult,
+          )
+        : this._completeExecution(specResult);
     } catch (error) {
       return this._failExecution(error);
     }
@@ -181,6 +199,59 @@ class Epic3Executor extends EpicExecutor {
     };
   }
 
+  /**
+   * Generate the spec by invoking a real agent through the orchestrator.
+   *
+   * epic: orchestration-consolidation, F1 — connects Epic 3 to the real executor
+   * (orchestrator.invokeAgent → SubagentDispatcher → claude). Returns the generated
+   * spec markdown, or null when no executor is wired or the agent produced nothing
+   * (the caller then falls back to an honest stub).
+   *
+   * @returns {Promise<string|null>} Generated spec markdown, or null
+   * @private
+   */
+  async _generateSpecViaAgent(storyId, source, techStack, context = {}) {
+    const invokeAgent = this.orchestrator && this.orchestrator.invokeAgent;
+    if (typeof invokeAgent !== 'function') {
+      return null; // No real executor wired → caller falls back to stub
+    }
+
+    const description =
+      `Generate a complete, implementation-ready specification (spec.md) for story "${storyId}". ` +
+      `Source: ${source || 'story'}. ` +
+      (techStack ? `Tech stack: ${JSON.stringify(techStack)}. ` : '') +
+      'Output ONLY the spec markdown: overview, scope (in/out), acceptance criteria, ' +
+      'dependencies and complexity estimate. No commentary outside the spec.';
+
+    try {
+      // Pass only serializable, prompt-relevant context — never the execution
+      // context wholesale (it carries `orchestrator: this` → circular reference).
+      const result = await invokeAgent(
+        { name: 'analyst' },
+        { id: `spec-${storyId}`, type: 'analysis', description },
+        { storyId, source, techStack, prdPath: context.prdPath },
+      );
+      const content = result && (result.output || result.content);
+      // Honesty: an agent "success" whose output is a CLI error banner or a
+      // few stray lines is NOT a spec. Require minimum substance + markdown
+      // structure before accepting, otherwise fall back to the honest stub.
+      const looksLikeSpec =
+        typeof content === 'string' &&
+        content.trim().length >= 200 &&
+        /^#{1,3}\s/m.test(content) &&
+        !/issue with the selected model|may not exist or you may not have access/i.test(content);
+      if (result && result.success !== false && looksLikeSpec) {
+        return content;
+      }
+      if (content && !looksLikeSpec) {
+        this._log('Agent output rejected (not a plausible spec) — falling back to stub', 'warn');
+      }
+    } catch (err) {
+      this._log(`Spec agent invocation failed: ${err.message}`, 'warn');
+    }
+    return null;
+  }
+
   /**
    * Create stub spec file
    * @private

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

@@ -105,37 +105,83 @@ class Epic4Executor extends EpicExecutor {
         }
       }
 
-      // Execute subtasks
-      const subtaskResults = await this._executeSubtasks(storyId, tracker, context);
+      // F1/convergência (epic: orchestration-consolidation): Epic 4 no longer
+      // re-implements execution. It DELEGATES to the BuildOrchestrator — the single
+      // real build path (worktree → plan → execute via claude → QA → merge). This
+      // kills the duplication the audit flagged (two competing execution engines).
+      if (this._realExecutionAllowed()) {
+        const buildResult = await this._executeViaBuildOrchestrator(storyId, context);
+        if (buildResult && buildResult.success) {
+          return this._completeExecution({
+            implementationPath: planPath,
+            planPath,
+            build: buildResult,
+            reportPath: buildResult.reportPath,
+            phases: buildResult.phases,
+          });
+        }
+        // Build actually ran and failed → honest failure (not a stub, not fake success).
+        return this._failExecution(
+          (buildResult && buildResult.error) || 'BuildOrchestrator failed',
+        );
+      }
 
-      // Collect code changes
+      // Fallback (test runner without SINAPSE_REAL_DISPATCH): honest stub — never
+      // fabricate success. Preserves the F0a invariant and keeps unit tests fast.
+      const subtaskResults = await this._executeSubtasks(storyId, tracker, context);
       const codeChanges = this._collectCodeChanges(subtaskResults);
-
-      // Run tests if available
       const testResults = await this._runTests(context);
-
-      // Calculate final progress
       const progress = {
         total: subtaskResults.length,
         completed: subtaskResults.filter((r) => r.success).length,
         failed: subtaskResults.filter((r) => !r.success).length,
       };
-
       this._addArtifact('progress', JSON.stringify(progress));
-
-      return this._completeExecution({
-        implementationPath: planPath,
-        planPath,
-        progress,
-        subtaskResults,
-        codeChanges,
-        testResults,
-      });
+      return this._stubExecution(
+        'Epic 4 stub mode — real build is delegated to BuildOrchestrator outside the test runner',
+        {
+          implementationPath: planPath,
+          planPath,
+          progress,
+          subtaskResults,
+          codeChanges,
+          testResults,
+        },
+      );
     } catch (error) {
       return this._failExecution(error);
     }
   }
 
+  /**
+   * Delegate execution to the BuildOrchestrator — the single real build path.
+   *
+   * epic: orchestration-consolidation, F1/convergence — instead of re-implementing
+   * the build (and duplicating it), Epic 4 hands off to the BuildOrchestrator, which
+   * runs plan → execute (claude) → QA → merge. Conservative defaults inside the
+   * pipeline (no worktree/merge side-effects, QA is Epic 6's job); tune via
+   * context.buildOptions.
+   *
+   * @returns {Promise<Object>} BuildOrchestrator result ({ success, ... })
+   * @private
+   */
+  async _executeViaBuildOrchestrator(storyId, context) {
+    try {
+      const { BuildOrchestrator } = require('../../execution/build-orchestrator');
+      const builder = new BuildOrchestrator({
+        rootPath: this.projectRoot,
+        useWorktree: false,
+        autoMerge: false,
+        runQA: false,
+        ...(context.buildOptions || {}),
+      });
+      return await builder.build(storyId, context.buildOptions || {});
+    } catch (err) {
+      this._log(`BuildOrchestrator delegation failed: ${err.message}`, 'error');
+      return { success: false, error: err.message };
+    }
+  }
+
   /**
    * Find existing plan or create new one
    * @private