sinapse-ai 1.19.1 → 1.20.0

package/.sinapse-ai/core/orchestration/cli-commands.js

@@ -52,6 +52,9 @@ try {
  * @param {number} [options.epic] - Start from specific epic (AC5)
  * @param {boolean} [options.dryRun] - Preview without execution (AC6)
  * @param {boolean} [options.strict] - Enable strict gate mode
+ * @param {'spec'|'plan'} [options.phaseLimit] - Stop after the given phase
+ *   (Story onda2-p3): 'spec' runs Epic 3 only; 'plan' runs Epics 3+4 with a
+ *   plan-only build. Both stop BEFORE build/QA.
  * @param {string} [options.projectRoot] - Project root path
  * @returns {Promise<Object>} Command result
  */
@@ -70,6 +73,16 @@ async function orchestrate(storyId, options = {}) {
   console.log(chalk.cyan.bold(`  🚀 SINAPSE Orchestrator: ${storyId}`));
   console.log(chalk.cyan('═══════════════════════════════════════════════════════════\n'));
 
+  if (options.phaseLimit) {
+    console.log(
+      chalk.yellow(
+        options.phaseLimit === 'spec'
+          ? '📝 Phase limit: SPEC — generates the real spec, stops before plan/build/QA.\n'
+          : '🗺️  Phase limit: PLAN — generates real spec + plan, stops before build/QA.\n',
+      ),
+    );
+  }
+
   // Dry run mode (AC6)
   if (options.dryRun) {
     return await orchestrateDryRun(storyId, options);
@@ -80,6 +93,7 @@ async function orchestrate(storyId, options = {}) {
       storyId,
       strictGates: options.strict ?? false,
       dashboardAutoUpdate: true,
+      phaseLimit: options.phaseLimit || null,
     });
 
     // Start dashboard
@@ -105,9 +119,14 @@ async function orchestrate(storyId, options = {}) {
     // Display final result
     displayResult(result);
 
+    // Phase-limited runs (Story onda2-p3): show where the real artifacts landed.
+    if (options.phaseLimit) {
+      displayPhaseArtifacts(result, options.phaseLimit);
+    }
+
     return {
       success: result.success,
-      exitCode: result.success ? 0 : result.blocked ? 2 : 1,
+      exitCode: computeExitCode(result),
       result,
     };
   } catch (error) {
@@ -120,6 +139,80 @@ async function orchestrate(storyId, options = {}) {
   }
 }
 
+/**
+ * Execute the spec phase only (Story onda2-p3, audit AF-20260702 item 2.3).
+ *
+ * Thin subcommand over the SAME pipeline as `orchestrate` — runs Epic 3 (Spec)
+ * and stops BEFORE plan/build/QA. This is the hybrid's measured value (a real,
+ * quality spec for ONE story) exposed as its own product surface.
+ *
+ * @param {string} storyId - Story ID
+ * @param {Object} options - Same options as orchestrate (minus phaseLimit)
+ * @returns {Promise<Object>} Command result
+ */
+async function spec(storyId, options = {}) {
+  return orchestrate(storyId, { ...options, phaseLimit: 'spec' });
+}
+
+/**
+ * Execute the spec + plan phases only (Story onda2-p3, audit AF-20260702 item 2.3).
+ *
+ * Thin subcommand over the SAME pipeline as `orchestrate` — runs Epic 3 (Spec)
+ * and Epic 4 in plan-only mode (real implementation plan, persisted
+ * story-scoped), and stops BEFORE build/QA.
+ *
+ * @param {string} storyId - Story ID
+ * @param {Object} options - Same options as orchestrate (minus phaseLimit)
+ * @returns {Promise<Object>} Command result
+ */
+async function plan(storyId, options = {}) {
+  return orchestrate(storyId, { ...options, phaseLimit: 'plan' });
+}
+
+/**
+ * Map a finalized pipeline result to a process exit code.
+ *
+ * Story onda2-p3 (audit AF-20260702 item 2.2): PASS_QA_SKIPPED exits 0 — a good
+ * build whose QA could not run for INFRASTRUCTURE reasons (nested `claude`
+ * spawn failing on Windows) must not exit as a failure; the warning carries the
+ * "QA not executed" caveat. Real failures stay 1, blocked stays 2.
+ *
+ * @param {Object} result - Finalized pipeline result
+ * @returns {number} Exit code
+ * @private
+ */
+function computeExitCode(result) {
+  if (result.success) return 0;
+  if (result.verdict === 'PASS_QA_SKIPPED') return 0;
+  return result.blocked ? 2 : 1;
+}
+
+/**
+ * Print the real artifacts a phase-limited run produced (spec/plan paths).
+ * @param {Object} result - Finalized pipeline result (carries state.epics)
+ * @param {'spec'|'plan'} phaseLimit
+ * @private
+ */
+function displayPhaseArtifacts(result, phaseLimit) {
+  const epics = result.state?.epics || {};
+  const specPath = epics[3]?.result?.specPath;
+  const planPath = epics[4]?.result?.planPath;
+
+  if (specPath) {
+    console.log(chalk.green(`📝 Spec: ${specPath}`));
+  }
+  if (phaseLimit === 'plan' && planPath) {
+    console.log(chalk.green(`🗺️  Plan: ${planPath}`));
+  }
+  if (specPath || (phaseLimit === 'plan' && planPath)) {
+    console.log(
+      chalk.gray(
+        `\nNext: review the artifact${phaseLimit === 'plan' ? 's' : ''}, then implement (natively or via sinapse orchestrate).\n`,
+      ),
+    );
+  }
+}
+
 /**
  * Dry run orchestration (AC6)
  * @private
@@ -143,10 +236,12 @@ async function orchestrateDryRun(storyId, options) {
   const epicConfig = orchestrator.constructor.EPIC_CONFIG;
   const startEpic = options.epic || 3;
 
-  // Use dynamic epic list from config (excludes onDemand epics like Epic 5)
+  // Use dynamic epic list from config (excludes onDemand epics like Epic 5).
+  // Phase-limited runs (Story onda2-p3) preview only their own sequence.
+  const allowedEpics = MasterOrchestrator.phaseLimitSequence(options.phaseLimit || null);
   const epicNums = Object.keys(epicConfig)
     .map(Number)
-    .filter((num) => !epicConfig[num].onDemand)
+    .filter((num) => !epicConfig[num].onDemand && allowedEpics.includes(num))
     .sort((a, b) => a - b);
 
   for (const epicNum of epicNums) {
@@ -420,7 +515,7 @@ async function orchestrateResume(storyId, options = {}) {
 
     return {
       success: result.success,
-      exitCode: result.success ? 0 : result.blocked ? 2 : 1,
+      exitCode: computeExitCode(result),
       result,
     };
   } catch (error) {
@@ -472,6 +567,11 @@ function displayResult(result) {
 
   if (result.success) {
     console.log(chalk.green.bold('  ✅ ORCHESTRATION COMPLETE'));
+  } else if (result.verdict === 'PASS_QA_SKIPPED') {
+    // Story onda2-p3 (audit AF-20260702 item 2.2): a good build whose QA could
+    // not execute (infrastructure — e.g. nested `claude` spawn failing on
+    // Windows) is NOT a failure. Never collapse it into FAILED.
+    console.log(chalk.yellow.bold('  ✅ BUILD OK — QA SKIPPED (infrastructure limitation)'));
   } else if (result.blocked) {
     console.log(chalk.red.bold('  🚫 ORCHESTRATION BLOCKED'));
   } else {
@@ -483,6 +583,13 @@ function displayResult(result) {
   console.log(chalk.gray(`\nDuration: ${result.duration || 'N/A'}`));
   console.log(chalk.gray(`Epics Executed: ${result.epics?.executed?.length || 0}`));
 
+  // Story onda2-p3 (audit AF-20260702 item 2.2): the pipeline's warning was
+  // computed but never shown — the one line that explains a red verdict (e.g.
+  // "QA ran in STUB mode") stayed hidden. Always surface it.
+  if (result.warning) {
+    console.log(chalk.yellow(`\n⚠️  ${result.warning}`));
+  }
+
   if (result.errors?.length > 0) {
     console.log(chalk.red(`\nErrors: ${result.errors.length}`));
     for (const err of result.errors.slice(0, 3)) {
@@ -570,12 +677,22 @@ module.exports = {
   orchestrateStop,
   orchestrateResume,
 
+  // Story onda2-p3: phase-limited subcommands (spec / spec+plan, no build/QA)
+  spec,
+  plan,
+
+  // Exported for tests (Story onda2-p3 — warning visibility + honest verdict)
+  displayResult,
+  computeExitCode,
+
   // Aliases for command parsing
   commands: {
     orchestrate: orchestrate,
     'orchestrate-status': orchestrateStatus,
     'orchestrate-stop': orchestrateStop,
     'orchestrate-resume': orchestrateResume,
+    spec: spec,
+    plan: plan,
   },
 };
 

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

@@ -36,7 +36,12 @@ class Epic4Executor extends EpicExecutor {
   _getPlanTracker() {
     if (!this._planTracker) {
       try {
-        const PlanTracker = require('../../infrastructure/scripts/plan-tracker');
+        // Path fix (audit AF-20260702 item 1.11): from executors/ this is 3
+        // levels up to .sinapse-ai/, not 2 — the old path resolved to the
+        // nonexistent core/infrastructure/. module.exports is an object, so
+        // the destructure is required too (a bare require(...) would have
+        // made `new PlanTracker(...)` explode on the exports object itself).
+        const { PlanTracker } = require('../../../infrastructure/scripts/plan-tracker');
         this._planTracker = PlanTracker;
       } catch (error) {
         this._log(`PlanTracker not available: ${error.message}`, 'warn');
@@ -113,13 +118,26 @@ 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,
+            // Story onda2-p3: a plan-only run persists the REAL plan story-scoped;
+            // prefer that path over the pre-created stub location.
+            planPath: buildResult.planPath || planPath,
+            ...(buildResult.planOnly === true ? { planOnly: true } : {}),
             // 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 +162,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/executors/epic-6-executor.js

@@ -55,6 +55,12 @@ class Epic6Executor extends EpicExecutor {
   async execute(context) {
     this._startExecution();
 
+    // Story onda2-p3 (audit AF-20260702 item 2.2): collect review-agent
+    // INVOCATION failures (spawn/CLI errors — infrastructure) separately from
+    // review verdicts, so the final result can distinguish "QA could not run"
+    // from a real QA rejection.
+    this._invocationFailures = [];
+
     try {
       const { buildResult, testResults, codeChanges, storyId, techStack } = context;
 
@@ -113,10 +119,26 @@ class Epic6Executor extends EpicExecutor {
 
       // Honesty invariant (F0a/F7): a QA loop that only ran deterministic basic
       // checks did NOT really review the work — it must report STUB, not success.
+      // Story onda2-p3: when the stub is caused by a FAILED agent invocation
+      // (spawn error — e.g. nested `claude` exiting 0xC0000142 on Windows), mark
+      // it as an infrastructure failure so the pipeline verdict can distinguish
+      // "QA not executable here" from a real QA rejection.
       if (!anyRealReview) {
+        const invocationFailed =
+          Array.isArray(this._invocationFailures) && this._invocationFailures.length > 0;
         return this._stubExecution(
-          'QA ran deterministic basic checks only — no real review agent wired',
-          baseResult,
+          invocationFailed
+            ? 'QA could not run: review-agent invocation failed (infrastructure error, not a test rejection) — only deterministic basic checks ran'
+            : 'QA ran deterministic basic checks only — no real review agent wired',
+          {
+            ...baseResult,
+            ...(invocationFailed
+              ? {
+                  infrastructureFailure: true,
+                  infrastructureErrors: [...this._invocationFailures],
+                }
+              : {}),
+          },
         );
       }
 
@@ -145,6 +167,9 @@ class Epic6Executor extends EpicExecutor {
         const realReview = await this._reviewViaAgent(invokeAgent, context);
         if (realReview) return realReview;
       } catch (error) {
+        // Thrown invocation error = the review process itself could not run
+        // (spawn/CLI failure) — infrastructure, never a review verdict.
+        this._recordInvocationFailure(error.message);
         this._log(`Real review failed, falling back to basic checks: ${error.message}`, 'warn');
       }
     }
@@ -197,6 +222,13 @@ class Epic6Executor extends EpicExecutor {
 
     const output = result && (result.output || result.content);
     if (!result || result.success === false || !output || output.trim().length === 0) {
+      // The dispatcher reports spawn/CLI failures by RETURNING { success:false,
+      // error } (it does not throw) — e.g. "Claude CLI exited with code
+      // 3221225794" on Windows. Record it as an infrastructure failure so the
+      // verdict never confuses "QA could not run" with a QA rejection.
+      if (result && result.success === false && result.error) {
+        this._recordInvocationFailure(result.error);
+      }
       return null;
     }
 
@@ -210,6 +242,25 @@ class Epic6Executor extends EpicExecutor {
     };
   }
 
+  /**
+   * Record a failed review-agent INVOCATION (spawn/CLI error).
+   *
+   * Story onda2-p3 (audit AF-20260702 item 2.2): this is the signal that lets
+   * the final pipeline verdict distinguish "QA could not run" (infrastructure —
+   * e.g. the nested `claude` spawn failing on Windows with exit 0xC0000142)
+   * from a real QA rejection, which always arrives as a review VERDICT
+   * (BLOCKED / NEEDS_REVISION), never through this path.
+   *
+   * @param {string} message - Invocation error message
+   * @private
+   */
+  _recordInvocationFailure(message) {
+    if (!Array.isArray(this._invocationFailures)) {
+      this._invocationFailures = [];
+    }
+    this._invocationFailures.push(String(message || 'unknown invocation failure'));
+  }
+
   /**
    * Parse a QA verdict from free-form agent output. Defaults to NEEDS_REVISION
    * (the safe, non-approving default) when no explicit verdict is found.

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/core/orchestration/index.js

@@ -204,6 +204,9 @@ module.exports = {
   orchestrateStatus: cliCommands.orchestrateStatus,
   orchestrateStop: cliCommands.orchestrateStop,
   orchestrateResume: cliCommands.orchestrateResume,
+  // Story onda2-p3: phase-limited subcommands (real spec / spec+plan, no build/QA)
+  spec: cliCommands.spec,
+  plan: cliCommands.plan,
 
   // Story 11.1: Executor Assignment (Projeto Bob)
   ExecutorAssignment,

package/.sinapse-ai/core/orchestration/master-orchestrator.js

@@ -166,6 +166,16 @@ class MasterOrchestrator extends EventEmitter {
     this.prdPath = options.prdPath || null;
     this.strictGates = options.strictGates ?? false;
 
+    // Story onda2-p3 (audit AF-20260702 item 2.3) — phase-limited runs expose the
+    // hybrid's MEASURED value (real spec + real plan for ONE story) as their own
+    // product surface: 'spec' runs Epic 3 only; 'plan' runs Epics 3+4 with a
+    // plan-only build. Both stop BEFORE build/QA. null = full pipeline.
+    const phaseLimit = options.phaseLimit || null;
+    if (phaseLimit !== null && !['spec', 'plan'].includes(phaseLimit)) {
+      throw new Error(`Invalid phaseLimit: ${phaseLimit} (expected 'spec' or 'plan')`);
+    }
+    this.phaseLimit = phaseLimit;
+
     // Callbacks
     this.onEpicStart = options.onEpicStart || this._defaultEpicStart.bind(this);
     this.onEpicComplete = options.onEpicComplete || this._defaultEpicComplete.bind(this);
@@ -444,9 +454,10 @@ class MasterOrchestrator extends EventEmitter {
     this._inFullPipeline = true;
 
     try {
-      // Execute epics in sequence: 3 → 4 → 6
+      // Execute epics in sequence: 3 → 4 → 6 — or a phase-limited prefix
+      // (Story onda2-p3): `sinapse spec` → [3], `sinapse plan` → [3, 4].
       // Note: Epic 5 (Recovery) is triggered on-demand, not sequentially
-      const epicSequence = [3, 4, 6];
+      const epicSequence = MasterOrchestrator.phaseLimitSequence(this.phaseLimit);
 
       for (const epicNum of epicSequence) {
         // Check if already completed (for resume scenarios)
@@ -563,6 +574,40 @@ class MasterOrchestrator extends EventEmitter {
     return [3, 4].includes(epicNum);
   }
 
+  /**
+   * Epic sequence for a given phase limit (Story onda2-p3).
+   *
+   * - 'spec' → [3]        (real spec only — stops before plan/build/QA)
+   * - 'plan' → [3, 4]     (spec + real plan; Epic 4 runs plan-only — stops before build/QA)
+   * - null   → [3, 4, 6]  (full pipeline)
+   *
+   * Single source of truth shared by the pipeline, the dry-run preview and the
+   * CLI so the sequence can never drift between them.
+   *
+   * @param {'spec'|'plan'|null} phaseLimit
+   * @returns {number[]} Epic sequence
+   */
+  static phaseLimitSequence(phaseLimit) {
+    if (phaseLimit === 'spec') return [3];
+    if (phaseLimit === 'plan') return [3, 4];
+    return [3, 4, 6];
+  }
+
+  /**
+   * Whether this epic is the LAST epic of a phase-limited run. The transition
+   * gate after it (e.g. epic4_to_epic6 with its `implementation_exists` check)
+   * guards an epic that will NOT run — evaluating it would wrongly block a
+   * spec/plan-only result that intentionally produced no implementation files.
+   * @param {number} epicNum
+   * @returns {boolean}
+   * @private
+   */
+  _isPhaseLimitTerminalEpic(epicNum) {
+    if (!this.phaseLimit) return false;
+    const seq = MasterOrchestrator.phaseLimitSequence(this.phaseLimit);
+    return epicNum === seq[seq.length - 1];
+  }
+
   // ═══════════════════════════════════════════════════════════════════════════════════
   //                              SINGLE EPIC EXECUTION (AC4)
   // ═══════════════════════════════════════════════════════════════════════════════════
@@ -659,8 +704,18 @@ class MasterOrchestrator extends EventEmitter {
       // Evaluate quality gate (Story 0.6) - only in full pipeline mode
       // Skip gate evaluation if result is from stub executor
       // (isStubResult already computed above with the failure-detection guard).
+      // Story onda2-p3: also skip for the terminal epic of a phase-limited run —
+      // the transition gate guards an epic that will not execute (e.g. the
+      // epic4_to_epic6 `implementation_exists` check would wrongly block a
+      // plan-only result that intentionally wrote no implementation files).
       let gateResult = null;
-      if (this._inFullPipeline && result && result.success !== false && !isStubResult) {
+      if (
+        this._inFullPipeline &&
+        result &&
+        result.success !== false &&
+        !isStubResult &&
+        !this._isPhaseLimitTerminalEpic(epicNum)
+      ) {
         gateResult = await this._evaluateGate(epicNum, result);
 
         // Store gate result if exists
@@ -824,6 +879,10 @@ class MasterOrchestrator extends EventEmitter {
           spec: this.executionState.epics[3]?.result?.specPath,
           complexity: this.executionState.epics[3]?.result?.complexity,
           requirements: this.executionState.epics[3]?.result?.requirements,
+          // Story onda2-p3: `sinapse plan` limits Epic 4 to the REAL plan —
+          // the BuildOrchestrator stops right after its plan phase (no build
+          // loop, no QA, no merge).
+          ...(this.phaseLimit === 'plan' ? { buildOptions: { planOnly: true } } : {}),
         };
 
       case 5: // Recovery (on-demand)
@@ -1536,27 +1595,66 @@ class MasterOrchestrator extends EventEmitter {
     // instead of "ORCHESTRATION COMPLETE" / exit 0.
     const hasFailures = (pipelineResult.epicsFailed || []).length > 0;
     const blocked = this._state === OrchestratorState.BLOCKED;
+
+    // Honesty invariant (epic: orchestration-consolidation, F0a): a pipeline that ran
+    // any epic in STUB mode did NOT really build anything — it must not report success:true.
+    // A failed epic or a non-COMPLETE terminal state is likewise never a success.
+    const success =
+      (pipelineResult.success ?? this._state === OrchestratorState.COMPLETE) &&
+      !hasStubs &&
+      !hasFailures &&
+      !blocked;
+
+    // Story onda2-p3 (audit AF-20260702 item 2.2) — honest Windows verdict:
+    // when the build epics (3 + 4) really ran and the ONLY stub is the QA epic (6)
+    // because the review agent invocation itself failed (nested `claude` spawn —
+    // known Windows limitation, exit 0xC0000142 / STATUS_DLL_INIT_FAILED), the
+    // result is a GOOD build whose QA could not execute — infrastructure, not a
+    // test rejection. Distinguish it (PASS_QA_SKIPPED) instead of collapsing it
+    // into FAILED. `success` stays false (F0a: a stubbed QA is not a full pass);
+    // the verdict + warning carry the distinction to the user.
+    const stubbedList = pipelineResult.epicsStubbed || [];
+    const executedList = pipelineResult.epicsExecuted || [];
+    const qaInfraFailure =
+      this.executionState.epics?.[6]?.result?.infrastructureFailure === true;
+    const qaSkippedInfra =
+      hasStubs &&
+      !hasFailures &&
+      !blocked &&
+      stubbedList.length === 1 &&
+      stubbedList[0] === 6 &&
+      qaInfraFailure &&
+      [3, 4].every((num) => executedList.includes(num));
+
+    const verdict = success
+      ? 'PASS'
+      : qaSkippedInfra
+        ? 'PASS_QA_SKIPPED'
+        : blocked
+          ? 'BLOCKED'
+          : 'FAILED';
+
+    let warning;
+    if (qaSkippedInfra) {
+      warning =
+        'Build succeeded, but the QA step could not run in this environment: the nested review-agent spawn failed (known Windows limitation, exit 0xC0000142). The build output is real — review/QA it manually (see docs/epics/epic-orchestration-consolidation/KNOWN-LIMITATIONS.md).';
+    } else if (hasStubs) {
+      warning =
+        'Pipeline ran one or more epics in STUB mode — no real work was performed for those. This is not a successful build (see epic: orchestration-consolidation).';
+    }
+
     return {
       workflowId: this.executionState.workflowId,
       storyId: this.storyId,
       status: this._state,
       blocked,
-      // Honesty invariant (epic: orchestration-consolidation, F0a): a pipeline that ran
-      // any epic in STUB mode did NOT really build anything — it must not report success:true.
-      // A failed epic or a non-COMPLETE terminal state is likewise never a success.
-      success:
-        (pipelineResult.success ?? this._state === OrchestratorState.COMPLETE) &&
-        !hasStubs &&
-        !hasFailures &&
-        !blocked,
+      success,
+      verdict,
+      qaSkipped: qaSkippedInfra,
+      ...(this.phaseLimit ? { phaseLimit: this.phaseLimit } : {}),
       mode: hasStubs ? 'stub' : 'real',
-      stubbedEpics: pipelineResult.epicsStubbed || [],
-      ...(hasStubs
-        ? {
-            warning:
-              'Pipeline ran one or more epics in STUB mode — no real work was performed for those. This is not a successful build (see epic: orchestration-consolidation).',
-          }
-        : {}),
+      stubbedEpics: stubbedList,
+      ...(warning ? { warning } : {}),
       duration: `${minutes}m ${seconds}s`,
       durationMs: duration,
       techStack: TechStackDetector.getSummary(this.executionState.techStackProfile || {}),