Revert fast profile; keep post-Writer parallel fan-out

The fast profile was redundant — users who want to skip
Presentation memo or other best-effort passes can already disable
those agents through the architecture editor. Carrying both a
"profile" knob and per-agent toggles meant two ways to express the
same thing.

Removed: WorkflowOptions.profile, the six branches in workflow.py
that switched on it, the cadence parameters on
_strategist_should_run / _rolling_summary_should_run, and
tests/test_fast_profile.py.

Kept: the parallel fan-out of Skeptic paper review + Analytical
math review + Presentation memo (saves a couple LLM round-trips
per iteration on a real API). Replaced the old test file with
tests/test_post_writer_parallel.py which only pins the parallel
vs serial equivalence — the reason the fan-out is safe to keep.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: HaibaraAi137

src/halfseed/workflow.py

@@ -124,20 +124,6 @@ class WorkflowOptions:
     enable_latex_gate: bool = True
     enable_publishing: bool = True
     director_options: DirectorOptions | None = None
-    # "default" — full pipeline.
-    # "fast"    — skip best-effort passes that don't shape the next
-    #             iteration's input: presentation memo (briefing
-    #             reads fine without it), analytical math review
-    #             (Analytical's specialist round already covers it),
-    #             LaTeX compile gate. Strategist + rolling summary
-    #             cadence stretched to every 5 iterations, library
-    #             refactor to every 10. The trade-off is one
-    #             iteration of extra latency on Strategist
-    #             observations and a paper.tex that may carry a
-    #             LaTeX warning until the user runs latexmk
-    #             manually. Wall-clock saving on a real API is
-    #             roughly 30-50% per iteration.
-    profile: str = "default"
 
 
 class ResearchWorkflow:
@@ -708,15 +694,7 @@ def _run_iteration_inner(
         # passes, or after the cap exhausts (in which case the final
         # failure is the recorded result).
         latex_result = None
-        # Fast profile: skip the LaTeX compile gate + retry loop. The
-        # paper.tex still gets written, the user can latexmk it
-        # manually if they care; the gate is mainly a guardrail
-        # against the Writer producing un-compilable output, which is
-        # rare and one-iteration-asynchronous to fix anyway.
-        if (
-            self.options.enable_latex_gate
-            and self.options.profile != "fast"
-        ):
+        if self.options.enable_latex_gate:
             latex_result = self._run_latex_gate(project, state, store)
             attempt = 0
             MAX_LATEX_FIX_RETRIES = 2
@@ -1559,10 +1537,7 @@ def _emit_strategic_review(
             recent_reviews = store.list_strategic_reviews(project.id, limit=1)
         except Exception:
             recent_reviews = []
-        cadence = 5 if self.options.profile == "fast" else 3
-        if not _strategist_should_run(
-            latest_snap, recent_reviews, cadence=cadence,
-        ):
+        if not _strategist_should_run(latest_snap, recent_reviews):
             return
 
         director_id = self._agent_id_for_role(ROLE_KIND_DIRECTOR)
@@ -1766,10 +1741,8 @@ def _emit_rolling_summary(
         error, garbage output) skips silently. The legacy prior_summary
         path in `prior_iteration_summary` still works as a fallback.
         """
-        cadence = 5 if self.options.profile == "fast" else 3
         if not _rolling_summary_should_run(
-            iteration.iteration_number, project.rolling_summary,
-            cadence=cadence,
+            iteration.iteration_number, project.rolling_summary
         ):
             return
 
@@ -2493,13 +2466,8 @@ def _run_analytical_math_review(
         for the Writer to address.
 
         Returns empty when there is no Analytical agent, no paper, or
-        the LLM call fails — never raises. In ``profile="fast"`` we
-        skip this pass entirely; the Analytical specialist already
-        scrutinises equations during its own specialist round, so the
-        paper-level math sweep is redundant for fast iterations.
+        the LLM call fails — never raises.
         """
-        if self.options.profile == "fast":
-            return []
         analytical_id = self._analytical_specialist_id()
         if analytical_id is None or not self._agent_enabled(analytical_id):
             return []
@@ -4089,9 +4057,7 @@ def _maybe_run_library_refactor(
             list_modules,
         )
 
-        LIBRARY_REFACTOR_PERIOD = (
-            10 if self.options.profile == "fast" else 5
-        )
+        LIBRARY_REFACTOR_PERIOD = 5
         MIN_MODULES_TO_REFACTOR = 3
         if iteration.iteration_number <= 0:
             return
@@ -4400,13 +4366,7 @@ def _maybe_run_presentation_memo(
         the memo as an agent_call transcript is intentional — it lets
         the user audit it from the web UI in the same way as Director
         plans and Writer edits.
-
-        ``profile="fast"`` skips this pass — the briefing reads fine
-        without a memo, and the saving (one LLM call per iteration)
-        is what fast mode is for.
         """
-        if self.options.profile == "fast":
-            return ""
         presentation_id = self._agent_id_for_role(ROLE_KIND_PRESENTATION)
         if presentation_id is None or not self._agent_enabled(presentation_id):
             return ""
@@ -5876,7 +5836,7 @@ def _refresh_outstanding_section(text: str) -> str:
 
 
 def _rolling_summary_should_run(
-    iteration_number: int, current_summary: str, *, cadence: int = 3,
+    iteration_number: int, current_summary: str
 ) -> bool:
     """Decide whether to refresh the project's rolling summary.
 
@@ -5886,16 +5846,16 @@ def _rolling_summary_should_run(
         context as early as possible. Without this a project that
         started before P6 landed would not get a summary until
         iter 3.
-      * iteration_number is a multiple of ``cadence`` (default 3;
-        fast profile passes 5 to keep token cost lower).
+      * iteration_number is a multiple of 3 (default cadence;
+        keeps token cost predictable).
 
     Pure function so the trigger logic is independently testable.
     """
     if iteration_number < 2:
         return False
     if not (current_summary or "").strip():
         return True
-    return iteration_number % max(1, cadence) == 0
+    return iteration_number % 3 == 0
 
 
 def _wants_deep_consolidation(pivots: list[dict[str, Any]] | None) -> bool:
@@ -5919,20 +5879,14 @@ def _wants_deep_consolidation(pivots: list[dict[str, Any]] | None) -> bool:
     return False
 
 
-def _strategist_should_run(
-    latest_snap: Any,
-    recent_reviews: list,
-    *,
-    cadence: int = 3,
-) -> bool:
+def _strategist_should_run(latest_snap: Any, recent_reviews: list) -> bool:
     """Decide whether to run the Strategist this iteration.
 
     Triggers (any-of):
       * iteration_number == 1 — establish a baseline review.
       * latest_snap.risk_flags non-empty — react to trouble immediately
         rather than waiting for the periodic cadence.
-      * ≥ ``cadence`` iterations since the last review — periodic
-        re-assess (default 3; fast profile passes 5).
+      * ≥ 3 iterations since the last review — periodic re-assess.
 
     Pure function so the trigger logic is unit-testable without
     needing a full workflow setup.
@@ -5946,7 +5900,7 @@ def _strategist_should_run(
     if not recent_reviews:
         return True  # never run before; do an initial review now
     last_review_iter = int(recent_reviews[0].iteration_number or 0)
-    return (latest_snap.iteration_number - last_review_iter) >= max(1, cadence)
+    return (latest_snap.iteration_number - last_review_iter) >= 3
 
 
 def _clamp01(value: Any) -> float: