sinapse-ai 1.20.0 → 1.21.0

package/.sinapse-ai/core/atlas/render-html.js

@@ -162,17 +162,19 @@ renderDiagrams('s-model'); // initial visible tab
 
 function tbl(cols,rows){return '<table><thead><tr>'+cols.map(c=>'<th>'+c+'</th>').join('')+'</tr></thead><tbody>'+
   rows.map(r=>'<tr>'+r.map(c=>'<td>'+c+'</td>').join('')+'</tr>').join('')+'</tbody></table>';}
-const code=s=>'<code>'+(s||'')+'</code>';
-const sev=s=>'<span class="tag'+(/NON-NEGOTIABLE/.test(s)?' nn':'')+'">'+s+'</span>';
+// Data cells come from atlas-data.json (framework registry, mutable via PR) — escape before innerHTML.
+const esc=s=>String(s).replace(/[&<>"']/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
+const code=s=>'<code>'+esc(s||'')+'</code>';
+const sev=s=>'<span class="tag'+(/NON-NEGOTIABLE/.test(s)?' nn':'')+'">'+esc(s)+'</span>';
 
 document.getElementById('t-constitution').innerHTML=tbl(['Art.','Principle','Severity'],
-  D.articles.map(a=>[a.number,a.title,sev(a.severity)]));
+  D.articles.map(a=>[esc(a.number),esc(a.title),sev(a.severity)]));
 
 document.getElementById('t-squads').innerHTML=tbl(['Squad','Name','Agents','Workflows','Orchestrators'],
-  D.squads.map(s=>[code(s.id),s.name,s.agents,s.workflows,(s.orqx||[]).map(code).join(' ')||'—']));
+  D.squads.map(s=>[code(s.id),esc(s.name),esc(s.agents),esc(s.workflows),(s.orqx||[]).map(code).join(' ')||'—']));
 
 document.getElementById('t-rules').innerHTML=tbl(['Rule','Governs'],
-  D.rules.map(r=>[code(r.id),r.title]));
+  D.rules.map(r=>[code(r.id),esc(r.title)]));
 
 // Workflows (search + source filter)
 function renderWorkflows(){
@@ -185,14 +187,14 @@ function renderWorkflows(){
   });
   document.getElementById('c-workflows').textContent=rows.length+' of '+D.workflows.length;
   document.getElementById('t-workflows').innerHTML=tbl(['Workflow','Source','Type','Description'],
-    rows.map(w=>[code(w.id),w.squad?code(w.squad):'<span class="tag">framework</span>',w.type||'—',w.description||'—']));
+    rows.map(w=>[code(w.id),w.squad?code(w.squad):'<span class="tag">framework</span>',esc(w.type||'—'),esc(w.description||'—')]));
 }
 ['q-workflows','f-workflows-src'].forEach(id=>document.getElementById(id).addEventListener('input',renderWorkflows));
 
 // Agents (search + squad filter + orqx toggle)
 const squads=[...new Set(D.agents.map(a=>a.squad))].sort();
 const sel=document.getElementById('f-agents-squad');
-sel.innerHTML='<option value="">all squads</option>'+squads.map(s=>'<option>'+s+'</option>').join('');
+sel.innerHTML='<option value="">all squads</option>'+squads.map(s=>'<option>'+esc(s)+'</option>').join('');
 function renderAgents(){
   const q=(document.getElementById('q-agents').value||'').toLowerCase();
   const sq=sel.value; const onlyOrqx=document.getElementById('f-agents-orqx').checked;
@@ -202,7 +204,7 @@ function renderAgents(){
   });
   document.getElementById('c-agents').textContent=rows.length+' of '+D.agents.length;
   document.getElementById('t-agents').innerHTML=tbl(['Agent','Persona','Squad','Role',''],
-    rows.map(a=>[code(a.id),a.persona||'—',code(a.squad),a.role||a.title||'—',a.isOrqx?'<span class="tag nn">orqx</span>':'']));
+    rows.map(a=>[code(a.id),esc(a.persona||'—'),code(a.squad),esc(a.role||a.title||'—'),a.isOrqx?'<span class="tag nn">orqx</span>':'']));
 }
 ['q-agents','f-agents-orqx'].forEach(id=>document.getElementById(id).addEventListener('input',renderAgents));
 sel.addEventListener('change',renderAgents);

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

@@ -0,0 +1,219 @@
+/**
+ * Brownfield Discovery — deterministic progress + QA gate in code.
+ *
+ * Story onda3-s3-brownfield-progress-gate (AF-20260702 item 3.3).
+ *
+ * The 10 phases of brownfield-discovery.yaml are executed by agents (prose,
+ * orchestrate-then-handoff). What was missing — and what this module adds —
+ * is the DETERMINISTIC layer around that prose:
+ *
+ *   1. resolveBrownfieldProgress(): where the assessment actually stands,
+ *      measured from artifacts ON DISK (not from what anyone claims), giving
+ *      an exact resume point per phase.
+ *   2. evaluateQaGate() / recordRework(): the Phase 7 verdict (APPROVED /
+ *      NEEDS WORK) parsed from docs/reviews/qa-review.md by code, with a
+ *      persisted rework counter capped at MAX_REWORK — the NEEDS WORK loop
+ *      escalates instead of spinning forever.
+ *
+ * Honesty contract: an unfilled template ("[APPROVED / NEEDS WORK]") is
+ * PENDING, not a verdict. Autonomous fan-out of phases 1-3 remains gated on
+ * a measured pilot (same pre-registered gate as epic waves — see the epic
+ * README of epic-onda3-estrutural); this module is the safe deterministic
+ * substrate either way.
+ *
+ * @module core/orchestration/brownfield-progress
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const { fileHasContent } = require('./doc-first-resolver');
+
+const QA_REVIEW_RELPATH = path.join('docs', 'reviews', 'qa-review.md');
+const STATE_RELPATH = path.join('.sinapse', 'workflow-state', 'brownfield-discovery.json');
+
+/** Rework ceiling for the Phase 7 loop (NEEDS WORK → fix → re-review). */
+const MAX_REWORK = 2;
+
+/** Normalize a step's `creates` (string | string[]) into a string list. */
+function listArtifacts(step) {
+  if (!step || !step.creates) return [];
+  const raw = Array.isArray(step.creates) ? step.creates : [step.creates];
+  return raw.filter((a) => typeof a === 'string' && a.trim().length > 0);
+}
+
+/** Glob-ish artifacts ("story-X.X-*.md") cannot be verified deterministically. */
+function isCheckable(artifact) {
+  return !artifact.includes('*');
+}
+
+/**
+ * Resolve the real state of the brownfield discovery from disk.
+ *
+ * @param {string} projectRoot
+ * @param {Object} workflow - Parsed `workflow` node (needs `.sequence`)
+ * @returns {{phases: Array, nextPhase: ?number, complete: boolean}}
+ */
+function resolveBrownfieldProgress(projectRoot, workflow) {
+  const sequence = (workflow && Array.isArray(workflow.sequence)) ? workflow.sequence : [];
+  const byPhase = new Map();
+
+  for (const step of sequence) {
+    if (!step || typeof step.phase !== 'number') continue;
+    if (!byPhase.has(step.phase)) {
+      byPhase.set(step.phase, { phase: step.phase, name: step.phase_name || null, steps: [] });
+    }
+    const artifacts = listArtifacts(step).map((artifact) => {
+      const checkable = isCheckable(artifact);
+      return {
+        path: artifact,
+        checkable,
+        exists: checkable ? fileHasContent(path.join(projectRoot, artifact)) : null,
+      };
+    });
+    byPhase.get(step.phase).steps.push({
+      id: step.step || step.id || null,
+      agent: step.agent || null,
+      conditional: Boolean(step.condition),
+      condition: step.condition || null,
+      artifacts,
+    });
+  }
+
+  const phases = [...byPhase.values()].sort((a, b) => a.phase - b.phase);
+
+  for (const phase of phases) {
+    // Required = checkable artifacts of unconditional steps. Conditional steps
+    // (e.g. project_has_database) never block completeness — but when their
+    // artifacts DO exist they are reported, so nothing done is invisible.
+    const required = phase.steps
+      .filter((s) => !s.conditional)
+      .flatMap((s) => s.artifacts.filter((a) => a.checkable));
+    const present = required.filter((a) => a.exists);
+    phase.requiredCount = required.length;
+    phase.presentCount = present.length;
+    if (required.length === 0) {
+      phase.status = 'unverifiable';
+    } else if (present.length === required.length) {
+      phase.status = 'complete';
+    } else if (present.length > 0) {
+      phase.status = 'partial';
+    } else {
+      phase.status = 'pending';
+    }
+  }
+
+  const firstIncomplete = phases.find(
+    (p) => p.status === 'pending' || p.status === 'partial',
+  );
+
+  return {
+    phases,
+    nextPhase: firstIncomplete ? firstIncomplete.phase : null,
+    complete: phases.length > 0 && !firstIncomplete,
+  };
+}
+
+/**
+ * Parse the Phase 7 verdict out of qa-review.md content.
+ *
+ * @param {string} content
+ * @returns {'approved'|'needs_work'|'pending'|'malformed'}
+ */
+function parseQaGateStatus(content) {
+  if (typeof content !== 'string') return 'malformed';
+  const m = content.match(/gate status:\s*(.*)$/im);
+  if (!m) return 'pending';
+  const value = m[1].trim();
+  const hasApproved = /approved/i.test(value);
+  const hasNeedsWork = /needs\s+work/i.test(value);
+  // The unfilled template is "[APPROVED / NEEDS WORK]" — both tokens present
+  // means the reviewer never picked. That is PENDING, never a verdict.
+  if (hasApproved && hasNeedsWork) return 'pending';
+  if (hasApproved) return 'approved';
+  if (hasNeedsWork) return 'needs_work';
+  return 'malformed';
+}
+
+function statePath(projectRoot) {
+  return path.join(projectRoot, STATE_RELPATH);
+}
+
+function readState(projectRoot) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(statePath(projectRoot), 'utf8'));
+    return { reworkCount: 0, ...parsed };
+  } catch {
+    return { reworkCount: 0 };
+  }
+}
+
+function writeState(projectRoot, state) {
+  const file = statePath(projectRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+
+/**
+ * Evaluate the Phase 7 QA gate deterministically (read-only — never mutates
+ * the rework counter; that is recordRework's job).
+ *
+ * @param {string} projectRoot
+ * @returns {{verdict: string, reworkCount: number, maxRework: number, escalate: boolean, reviewPath: string, reason?: string}}
+ */
+function evaluateQaGate(projectRoot) {
+  const reviewPath = path.join(projectRoot, QA_REVIEW_RELPATH);
+  const state = readState(projectRoot);
+  const base = {
+    reworkCount: state.reworkCount,
+    maxRework: MAX_REWORK,
+    reviewPath: QA_REVIEW_RELPATH,
+  };
+
+  if (!fileHasContent(reviewPath)) {
+    return { ...base, verdict: 'pending', escalate: false, reason: 'qa-review.md ausente ou vazio' };
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(reviewPath, 'utf8');
+  } catch (error) {
+    return { ...base, verdict: 'malformed', escalate: false, reason: `qa-review.md ilegível: ${error.message}` };
+  }
+
+  const verdict = parseQaGateStatus(content);
+  const escalate = verdict === 'needs_work' && state.reworkCount >= MAX_REWORK;
+  return { ...base, verdict, escalate };
+}
+
+/**
+ * Record one NEEDS WORK → rework loop iteration. Call it when the flow
+ * returns to Phase 4 after a NEEDS WORK verdict. At MAX_REWORK the gate
+ * escalates instead of looping.
+ *
+ * @param {string} projectRoot
+ * @returns {{reworkCount: number, escalate: boolean}}
+ */
+function recordRework(projectRoot) {
+  const state = readState(projectRoot);
+  state.reworkCount += 1;
+  state.lastReworkAt = new Date().toISOString();
+  writeState(projectRoot, state);
+  return { reworkCount: state.reworkCount, escalate: state.reworkCount >= MAX_REWORK };
+}
+
+/** Reset the rework counter (new assessment cycle). */
+function resetQaGateState(projectRoot) {
+  writeState(projectRoot, { reworkCount: 0 });
+}
+
+module.exports = {
+  resolveBrownfieldProgress,
+  parseQaGateStatus,
+  evaluateQaGate,
+  recordRework,
+  resetQaGateState,
+  MAX_REWORK,
+};

package/.sinapse-ai/core/orchestration/doc-first-resolver.js

@@ -319,4 +319,7 @@ module.exports = {
   TYPE_KEYWORDS,
   // re-exported for callers that want the raw map
   GREENFIELD_WORKFLOW_BY_TYPE,
+  // Onda3-S2 (AF-20260702 item 3.4): exported so artifact gates share ONE
+  // definition of "artifact exists and is non-empty" instead of forking it.
+  fileHasContent,
 };

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/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/registry/service-registry.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
   "generated": "2026-06-19T20:32:21.238Z",
-  "totalWorkers": 373,
+  "totalWorkers": 372,
   "categories": {
     "checklist": {
       "count": 16,
@@ -24,7 +24,7 @@
       "description": "JavaScript utility scripts"
     },
     "task": {
-      "count": 215,
+      "count": 214,
       "subcategories": [
         "analysis",
         "creation",
@@ -10933,36 +10933,6 @@
         "addedVersion": "1.0.0"
       }
     },
-    {
-      "id": "waves",
-      "name": "Waves",
-      "description": "<!-- Story: WIS-4 - Wave Analysis Engine -->",
-      "category": "task",
-      "subcategory": "general",
-      "inputs": [],
-      "outputs": [],
-      "tags": [
-        "task",
-        "general",
-        "waves"
-      ],
-      "path": ".sinapse-ai/development/tasks/waves.md",
-      "taskFormat": "TASK-FORMAT-V1",
-      "executorTypes": [
-        "Agent",
-        "Worker"
-      ],
-      "performance": {
-        "avgDuration": "1m",
-        "cacheable": false,
-        "parallelizable": false
-      },
-      "agents": [],
-      "metadata": {
-        "source": "development",
-        "addedVersion": "1.0.0"
-      }
-    },
     {
       "id": "yolo-toggle",
       "name": "Yolo Toggle",