sinapse-ai 1.20.1 → 1.21.0

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/data/entity-registry.yaml

@@ -1,7 +1,7 @@
 metadata:
   version: 1.0.0
-  lastUpdated: '2026-07-03T06:58:13.504Z'
-  entityCount: 813
+  lastUpdated: '2026-07-03T09:35:03.324Z'
+  entityCount: 814
   checksumAlgorithm: sha256
   resolutionRate: 100
 entities:
@@ -2959,8 +2959,8 @@ entities:
         score: 0.8
         constraints: []
         extensionPoints: []
-      checksum: sha256:a505eb0429e05d6c38e0836d7d60e98815aa70f10c855c0936dfde6731682343
-      lastVerified: '2026-07-03T06:55:48.479Z'
+      checksum: sha256:222b56327fd175c90bea4c89e3a1b82e27e94c28085a74530489682483038edd
+      lastVerified: '2026-07-03T09:35:03.116Z'
     export-design-tokens-dtcg:
       path: .sinapse-ai/development/tasks/export-design-tokens-dtcg.md
       layer: L2
@@ -11582,6 +11582,27 @@ entities:
         extensionPoints: []
       checksum: sha256:d4ad190353fc751e874bad5b3013137dcccfc84100edd6cead80c8fa5e83af11
       lastVerified: '2026-06-30T18:30:20.187Z'
+    brownfield-progress:
+      path: .sinapse-ai/core/orchestration/brownfield-progress.js
+      layer: L1
+      type: module
+      purpose: Entity at .sinapse-ai\core\orchestration\brownfield-progress.js
+      keywords:
+        - brownfield
+        - progress
+      usedBy:
+        - workflow-executor
+      dependencies:
+        - doc-first-resolver
+      externalDeps: []
+      plannedDeps: []
+      lifecycle: production
+      adaptability:
+        score: 0.4
+        constraints: []
+        extensionPoints: []
+      checksum: sha256:919fa899b32e584842f370df84cfefdc5d450136f13699c1916d82f3e1833b7d
+      lastVerified: '2026-07-03T08:52:22.751Z'
     build-command:
       path: .sinapse-ai/core/orchestration/build-command.js
       layer: L1
@@ -11738,7 +11759,9 @@ entities:
         - first
         - resolver
       usedBy:
+        - brownfield-progress
         - build-command
+        - greenfield-handler
         - route-command
       dependencies:
         - greenfield-handler
@@ -11749,8 +11772,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:92a4170f3ed0b6b214608c80e17c8c6b1769a50b849532af4ae34db070a6931f
-      lastVerified: '2026-06-27T21:56:17.335Z'
+      checksum: sha256:e309338d1ca98d70953563a2cf92bae261264fac8001f389afdb7fbf968be353
+      lastVerified: '2026-07-03T08:39:26.307Z'
     epic-context-accumulator:
       path: .sinapse-ai/core/orchestration/epic-context-accumulator.js
       layer: L1
@@ -11954,6 +11977,7 @@ entities:
         - bob-orchestrator
         - doc-first-resolver
       dependencies:
+        - doc-first-resolver
         - workflow-executor
         - surface-checker
         - session-state
@@ -11964,8 +11988,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:330be2c76c3eb5a9a1f1c975837308802b8fc6fb871f9b584787ae4e2aa8fcb1
-      lastVerified: '2026-06-30T18:30:20.192Z'
+      checksum: sha256:5f40108470bf2602e9ccb72c241ece5d1b9e801ba83e1864b8b1d5f34ae3e9e7
+      lastVerified: '2026-07-03T08:39:26.309Z'
     lock-manager:
       path: .sinapse-ai/core/orchestration/lock-manager.js
       layer: L1
@@ -12247,6 +12271,7 @@ entities:
         - executor-assignment
         - session-state
         - gate-evaluator
+        - brownfield-progress
       externalDeps: []
       plannedDeps: []
       lifecycle: production
@@ -12254,8 +12279,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:c7aca8a292efcf20185cd30d6a582c6239a55a9871e4e63ed1c49a6aebf35f7a
-      lastVerified: '2026-06-30T18:30:20.195Z'
+      checksum: sha256:aa21bf15ac3fec1170b6bf5a446051c93718c069b5afa44d75ed5557427597a6
+      lastVerified: '2026-07-03T08:52:22.755Z'
     workflow-orchestrator:
       path: .sinapse-ai/core/orchestration/workflow-orchestrator.js
       layer: L1
@@ -15059,8 +15084,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:6de267f13f4fd996450ed228ac6bb109d4d75f91eef515c946d5885e464f4fc9
-      lastVerified: '2026-06-15T00:26:26.478Z'
+      checksum: sha256:1cda821dcfd9dde90c00a9566588a6d5155d6265deaf926caf3477d9f8def921
+      lastVerified: '2026-07-03T08:52:22.790Z'
     brownfield-fullstack:
       path: .sinapse-ai/development/workflows/brownfield-fullstack.yaml
       layer: L2
@@ -15206,8 +15231,8 @@ entities:
         score: 0.4
         constraints: []
         extensionPoints: []
-      checksum: sha256:f795fafa52113f199a186bbb00624c1d93491363f5198d46b6793fb9fee63a5d
-      lastVerified: '2026-07-03T06:55:48.584Z'
+      checksum: sha256:fd22d105cfce45cf7202d947fcc145987ed07b8503ec8dfdd260fa5a43886345
+      lastVerified: '2026-07-03T09:35:03.241Z'
     fast-track:
       path: .sinapse-ai/development/workflows/fast-track.yaml
       layer: L2

package/.sinapse-ai/development/tasks/execute-epic-plan.md

@@ -835,6 +835,9 @@ Each story spawns the full development-cycle:
 ### epic-orchestration.yaml (template)
 Provides the generic wave pattern that this task instantiates with project-specific data from the EXECUTION.yaml.
 
+### Wave gate executável (scripts/wave-gate.js)
+Gate determinístico por wave: para cada diretório de story, verifica testes verdes E arquivos de produto realmente escritos (um plano não é implementação) → APPROVED/NEEDS_WORK com exit code. Uso: `node scripts/wave-gate.js --stories <dir1> <dir2> [--test-cmd "..."]`. **Nota de honestidade (medição 2026-07-03):** o wrapper autônomo de waves foi REPROVADO pelo protocolo pré-registrado (ver `docs/epics/epic-onda3-estrutural/CHECKPOINT-waves-2026-07-03.md`) — para multi-story prefira o caminho nativo; o gate permanece como utilitário de verificação por lote.
+
 ### po-epic-context.md
 Used by @product-lead during story validation to understand accumulated changes across the epic.
 

package/.sinapse-ai/development/workflows/brownfield-discovery.yaml

@@ -17,6 +17,22 @@ workflow:
   metadata:
     elicit: true
     confirmation_required: true
+    # Onda3-S3 (AF-20260702 item 3.3): phases 1-3 are declared parallelizable —
+    # their artifacts are independent (system/db/frontend). Autonomous fan-out
+    # of these phases is GATED on a measured pilot (same pre-registered gate as
+    # epic waves — docs/epics/epic-onda3-estrutural/README.md): until a
+    # measurement shows fan-out beating sequential handoff, execution stays
+    # manual per-agent. Deterministic progress + the Phase 7 QA gate come from
+    # core/orchestration/brownfield-progress.js (attached to the executeWorkflow
+    # handoff): resume points and the APPROVED/NEEDS WORK loop (max 2 reworks,
+    # then escalate) are measured from disk, not from prose.
+    parallelizable_phases: [1, 2, 3]
+    qa_gate:
+      phase: 7
+      review_artifact: docs/reviews/qa-review.md
+      verdicts: [APPROVED, NEEDS_WORK]
+      max_rework_cycles: 2
+      evaluator: .sinapse-ai/core/orchestration/brownfield-progress.js
     action_types:
       task-reference: "Action references an existing task file in .sinapse-ai/development/tasks/"
       agent-command: "Action references an agent-level command (e.g., *create-front-end-spec)"

package/.sinapse-ai/development/workflows/epic-orchestration.yaml

@@ -35,6 +35,17 @@ workflow:
   metadata:
     elicit: true
     confirmation_required: true
+    # HONESTIDADE (Onda3-S5, medido 2026-07-03): este template descreve o
+    # PATTERN de waves, mas não existe executor de waves em produção — e o
+    # piloto medido (docs/epics/epic-onda3-estrutural/CHECKPOINT-waves-2026-07-03.md)
+    # REPROVOU o wrapper de waves pelo critério pré-registrado (empate em
+    # correctness, ~2x o custo vs caminho nativo). Para multi-story, use o
+    # caminho nativo. O gate determinístico de wave existe como utilitário
+    # standalone: scripts/wave-gate.js (testes verdes + arquivos realmente
+    # escritos, por story). Reabertura só via novo piloto pelo mesmo protocolo
+    # (tests/evals/epic-gates/PROTOCOL.md).
+    production_status: pattern-only-no-executor
+    wave_gate_utility: scripts/wave-gate.js
 
   # ═══════════════════════════════════════════════════════════════════════════════════
   #                              EXECUTION MODES

package/.sinapse-ai/install-manifest.yaml

@@ -7,9 +7,9 @@
 # - SHA256 hashes for change detection
 # - File types for categorization
 #
-version: 1.20.1
+version: 1.21.0
 generator: scripts/generate-install-manifest.js
-file_count: 1153
+file_count: 1154
 files:
   - path: cli/commands/config/index.js
     hash: sha256:bfa83cb1dc111b0b30dd298dc0abc2150b73f939b6cd4458effa8e6d407bc9e2
@@ -923,6 +923,10 @@ files:
     hash: sha256:d4ad190353fc751e874bad5b3013137dcccfc84100edd6cead80c8fa5e83af11
     type: core
     size: 28745
+  - path: core/orchestration/brownfield-progress.js
+    hash: sha256:919fa899b32e584842f370df84cfefdc5d450136f13699c1916d82f3e1833b7d
+    type: core
+    size: 7585
   - path: core/orchestration/build-command.js
     hash: sha256:b758cfc7c0fad3d0d875460630b9ac7b2c968b82cdec14e9885e0744ee7012d0
     type: core
@@ -952,9 +956,9 @@ files:
     type: core
     size: 10880
   - path: core/orchestration/doc-first-resolver.js
-    hash: sha256:92a4170f3ed0b6b214608c80e17c8c6b1769a50b849532af4ae34db070a6931f
+    hash: sha256:e309338d1ca98d70953563a2cf92bae261264fac8001f389afdb7fbf968be353
     type: core
-    size: 14592
+    size: 14762
   - path: core/orchestration/epic-context-accumulator.js
     hash: sha256:9f38c7e3b4de7fbcfeae5fe1dc88aa3f0ae38667f1dc1da025519d40b3b9daa9
     type: core
@@ -1000,9 +1004,9 @@ files:
     type: core
     size: 23437
   - path: core/orchestration/greenfield-handler.js
-    hash: sha256:330be2c76c3eb5a9a1f1c975837308802b8fc6fb871f9b584787ae4e2aa8fcb1
+    hash: sha256:5f40108470bf2602e9ccb72c241ece5d1b9e801ba83e1864b8b1d5f34ae3e9e7
     type: core
-    size: 40129
+    size: 44211
   - path: core/orchestration/index.js
     hash: sha256:ee215f855804448dcb02375128f4ff1f39e6861f37d1762dde19c80e77b8f4a6
     type: core
@@ -1056,9 +1060,9 @@ files:
     type: core
     size: 16495
   - path: core/orchestration/workflow-executor.js
-    hash: sha256:c7aca8a292efcf20185cd30d6a582c6239a55a9871e4e63ed1c49a6aebf35f7a
+    hash: sha256:aa21bf15ac3fec1170b6bf5a446051c93718c069b5afa44d75ed5557427597a6
     type: core
-    size: 37636
+    size: 38414
   - path: core/orchestration/workflow-orchestrator.js
     hash: sha256:6e97eec88c8261f15bad79c47b0eafcfe39fbda5c837e156fe803802c3a1c18f
     type: core
@@ -1360,9 +1364,9 @@ files:
     type: data
     size: 9671
   - path: data/entity-registry.yaml
-    hash: sha256:166203aac0d019e100aff6a79145b2e83cf6b31d7d69374ffdc019e463ebf384
+    hash: sha256:c3e211656dbfb4dd5628e403728bc90ace0c1d2a1faa55385d60c8c873e46e08
     type: data
-    size: 557171
+    size: 557940
   - path: data/learned-patterns.yaml
     hash: sha256:1a4cd045c087b9dfd7046ff1464a9d2edb85fba77cf0b6fba14f4bb9004c741e
     type: data
@@ -2160,9 +2164,9 @@ files:
     type: task
     size: 8809
   - path: development/tasks/execute-epic-plan.md
-    hash: sha256:a505eb0429e05d6c38e0836d7d60e98815aa70f10c855c0936dfde6731682343
+    hash: sha256:222b56327fd175c90bea4c89e3a1b82e27e94c28085a74530489682483038edd
     type: task
-    size: 25478
+    size: 26107
   - path: development/tasks/export-design-tokens-dtcg.md
     hash: sha256:ce37d53f78d6ddab720e6d534d9da629497264ed72b620bc4ff1306ad0f6ffeb
     type: task
@@ -2960,9 +2964,9 @@ files:
     type: workflow
     size: 18594
   - path: development/workflows/brownfield-discovery.yaml
-    hash: sha256:6de267f13f4fd996450ed228ac6bb109d4d75f91eef515c946d5885e464f4fc9
+    hash: sha256:1cda821dcfd9dde90c00a9566588a6d5155d6265deaf926caf3477d9f8def921
     type: workflow
-    size: 33356
+    size: 34298
   - path: development/workflows/brownfield-fullstack.yaml
     hash: sha256:7be5f76d80bddea70b560c4fe9caa35d0534ec84e4d4ed0e120a99f68b73950d
     type: workflow
@@ -2984,9 +2988,9 @@ files:
     type: workflow
     size: 15633
   - path: development/workflows/epic-orchestration.yaml
-    hash: sha256:f795fafa52113f199a186bbb00624c1d93491363f5198d46b6793fb9fee63a5d
+    hash: sha256:fd22d105cfce45cf7202d947fcc145987ed07b8503ec8dfdd260fa5a43886345
     type: workflow
-    size: 16953
+    size: 17712
   - path: development/workflows/fast-track.yaml
     hash: sha256:1a4f5665af164b8c6425d2ff3c2e713ff8559a66066aa0c7cbd1c6773aaa8266
     type: workflow