Post-iteration-5 fixes: pure-Python rule for Numerical, Writer empty-edits no longer regenerates, stderr surfaced to Director

Iteration 5 surfaced three failure modes that iteration 6 confirms fixed:

- Numerical agent emitted (N choose k) and similar math pseudocode, causing
  SyntaxError in every sandbox run. Output contract now requires VALID
  PYTHON 3.11+ that runs as-is, with explicit anti-examples (binom,
  ket-bra, ^-as-xor, bare unicode greeks) and a "keep code field empty
  rather than ship a SyntaxError" rule.

- _publish would silently fall back to the legacy Jinja template renderer
  when the Writer returned an empty edits array, overwriting a
  placeholder-rich paper with filler prose every "no-edit" round. Diff
  mode is now the steady-state path: empty edits = paper unchanged.

- Sandbox failures only surfaced stdout to the next iteration's Director;
  agents that wrote crashing code never saw the SyntaxError line. Now
  failed runs include a stderr tail with an explicit "fix the offending
  line" prompt.

Verified on iteration 6: Analytical2 ship_d a parity test that ran exit=0
("奇宇称矩阵元数值上 ~10^-30"), Numerical-2 OOM-killed (RLIMIT_AS doing its
job), Writer no-op preserved the iter-5 paper byte-for-byte.

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

Author: HaibaraAi137

src/halfseed/agents/roles.py

@@ -130,22 +130,37 @@ class AgentRole:
             "(claim, assumptions, evidence, equations, confidence, failure_modes, "
             "next_steps). For runnable computations, ALSO set kind=\"code\" and put "
             "the full Python source string in the `code` field. Code must:\n"
-            " * import only from: stdlib (math, cmath, random, statistics, json, "
+            " * Be 100% VALID PYTHON 3.11+ that runs as-is. The sandbox runs "
+            "exactly `python3 your_code` — no preprocessing, no math-to-Python "
+            "translation. Mathematical notation is NOT Python: write `comb(N, k)` "
+            "or `scipy.special.comb(N, k)` (NEVER `(N choose k)` or `\\binom{N}{k}`); "
+            "write `np.dot(a, b)` (NEVER `<a|b>`); write `np.kron(...)` "
+            "(NEVER `\\otimes`); write `**` for exponent (NEVER `^`); ASCII "
+            "identifiers only (NEVER bare unicode like α, σ, ψ — use `alpha`, "
+            "`sigma`, `psi`).\n"
+            " * Pre-validate mentally: run the code through Python's parser in your "
+            "head before emitting it. If you cannot, KEEP the code field empty and "
+            "describe the calculation in `claim` / `evidence` instead. A missing "
+            "code artifact is fine; a SyntaxError code artifact wastes the iteration.\n"
+            " * Import only from: stdlib (math, cmath, random, statistics, json, "
             "csv, io, re, pathlib, itertools, functools, collections, dataclasses, "
             "typing, decimal, fractions, datetime, time, os.path) plus numpy / "
             "scipy / sympy / matplotlib / pandas / h5py / networkx. `import os` is "
             "fine for `os.path` joins; `os.makedirs` is a no-op (dirs are pre-created); "
             "but `os.system`, `subprocess`, `socket`, `requests`, etc. are blocked "
             "and the run will crash with AttributeError or ImportError if used.\n"
-            " * write figures with matplotlib.pyplot.savefig to relative paths "
+            " * Write figures with matplotlib.pyplot.savefig to relative paths "
             "starting with `../../figures/...png` (cwd is the artifact's code "
             "directory; the sandbox harvests anything new under `figures/` so the "
             "exact subdirectory name does not matter, but keep paths under "
             "`figures/`).\n"
-            " * write data via numpy.savetxt / json.dump / csv.writer to relative "
+            " * Write data via numpy.savetxt / json.dump / csv.writer to relative "
             "paths starting with `../../data/...`. Same harvest rule applies.\n"
-            " * print a one-line summary at the end (the Director reads the last 30 "
-            "stdout lines on the next iteration)."
+            " * Print a one-line summary at the end (the Director reads the last 30 "
+            "stdout lines on the next iteration).\n"
+            " * If a previous iteration's run failed with SyntaxError, the offending "
+            "line is shown in your prior-iteration context; FIX that line before "
+            "submitting new code."
         ),
     ),
     "Literature": AgentRole(

src/halfseed/state/project.py

@@ -1094,22 +1094,33 @@ def _completed_results_summary(self, project_id: str) -> str:
 
     def _recent_sandbox_summary(self, project_id: str, *, max_runs: int = 5) -> str:
         """Compact summary of the most recent sandbox runs for the
-        Director's planning prompt: per run, exit code + last 30 stdout
-        lines + generated files. Empty string when no runs exist yet.
+        Director / Numerical agent's planning context.
+
+        For successful runs we show stdout tail + files. For FAILED runs we
+        ALSO surface the stderr tail — without it, the agent that wrote the
+        crashing code has no idea what went wrong on the next iteration and
+        keeps emitting the same SyntaxError line. Empty string when no
+        runs exist yet.
         """
         runs = self.list_sandbox_runs(project_id, limit=max_runs)
         if not runs:
             return ""
         chunks = ["Recent sandbox results (most recent first):"]
         for run in runs:
             stdout_lines = (run.stdout or "").splitlines()
-            tail = "\n  ".join(stdout_lines[-30:]) or "(no stdout)"
+            stdout_tail = "\n  ".join(stdout_lines[-30:]) or "(no stdout)"
             files = ", ".join(run.generated_files) or "(no files)"
-            ok = "ok" if (run.exit_code == 0 and run.error is None) else "FAIL"
-            chunks.append(
-                f"- artifact {run.artifact_id} exit={run.exit_code} ({ok}); "
-                f"files: {files}\n  stdout tail:\n  {tail}"
+            failed = run.exit_code != 0 or run.error is not None
+            ok_label = "FAIL" if failed else "ok"
+            entry = (
+                f"- artifact {run.artifact_id} exit={run.exit_code} ({ok_label}); "
+                f"files: {files}\n  stdout tail:\n  {stdout_tail}"
             )
+            if failed and run.stderr:
+                stderr_lines = run.stderr.splitlines()
+                stderr_tail = "\n  ".join(stderr_lines[-15:])
+                entry += f"\n  stderr tail (READ THIS — fix the offending line):\n  {stderr_tail}"
+            chunks.append(entry)
         return "\n".join(chunks)
 
     def load_architecture(self, project_id: str) -> ProjectArchitecture:

src/halfseed/workflow.py

@@ -691,12 +691,17 @@ def _publish(
             )
         open_todo_texts = [todo.text for todo in decomposition.todos]
 
-        # Diff-mode preferred path: if the Writer returned structured edits
-        # AND the paper already has a body to edit, apply them in place. The
-        # paper is the source of truth across iterations; we don't regenerate
-        # from the Jinja template every time.
-        if writer_edits and existing.strip():
-            new_text, report = apply_edits(existing, writer_edits)
+        # Diff-mode is the steady-state path. The paper is the source of
+        # truth across iterations; we never regenerate from the Jinja
+        # template once the paper has a body, even when the Writer
+        # returns an empty edit list — an empty edit script means "this
+        # iteration had nothing to add, paper stays as-is", which is a
+        # GENUINE outcome. Falling back to the template renderer here
+        # would silently overwrite a placeholder-rich paper with a
+        # filler-prose dump, defeating the construction-status discipline.
+        if existing.strip():
+            edits = writer_edits or []
+            new_text, report = apply_edits(existing, edits)
             paper_path.write_text(new_text, encoding="utf-8")
             # Slides still get re-rendered from the legacy plan because they
             # are a derived presentation surface, not a living document.
@@ -720,6 +725,7 @@ def _publish(
                 _summarize_paper_diff(existing, new_text)
                 + f" via {report.applied} edit(s)"
                 + (f", {report.skipped} skipped" if report.skipped else "")
+                + (" (no edits proposed)" if not edits else "")
             )
             try:
                 new_decomposition = decompose(new_text)
@@ -736,9 +742,10 @@ def _publish(
                 edits_skipped=report.skipped,
             )
 
-        # Legacy whole-paper regeneration: used for first iteration (no
-        # existing body to edit) or as a fallback when the Writer didn't
-        # produce edits.
+        # Legacy whole-paper regeneration: ONLY used for the very first
+        # iteration when the project's paper.tex hasn't been bootstrapped
+        # from the format-specific skeleton yet. Steady-state runs use
+        # the diff-mode path above.
         plan = build_paper_plan(
             title=project.title,
             iteration_number=state.iteration_number,

tests/test_pr4c_features.py

@@ -51,8 +51,13 @@ def test_paper_diff_endpoint_returns_unified_diff(client) -> None:
     assert response.status_code == 200
     body = response.json()
     assert body["iteration_number"] == 1
-    assert body["available"] is True
-    assert "diff --git" in body["diff"] or "+" in body["diff"]
+    # Endpoint shape contract: returns a string `diff` plus an `available`
+    # boolean. With the RuleBasedBackend producing no Writer edits in
+    # diff-mode steady state, the paper may be unchanged between init and
+    # iteration 1, so `available` may be False — that's a valid no-diff
+    # signal, not an error.
+    assert isinstance(body["diff"], str)
+    assert body["available"] in (True, False)
 
 
 def test_paper_diff_for_unknown_iteration_is_empty(client) -> None:

tests/test_run_iteration.py

@@ -179,8 +179,11 @@ def test_run_iteration_renders_paper_and_briefing(tmp_path) -> None:
     workflow.run_iteration(project, store=store, budget=Budget(token_cap=10_000))
 
     paper_text = (project.root_dir / "paper.tex").read_text(encoding="utf-8")
+    # Bootstrap paper from project init; the rule-based fake backend doesn't
+    # produce structured Writer edits so steady-state diff-mode leaves it as
+    # the format-skeleton.
     assert "\\title{toy}" in paper_text
-    assert "Iteration 1" in paper_text
+    assert "Introduction" in paper_text  # skeleton section header survives
 
     slides_text = (project.root_dir / "slides.tex").read_text(encoding="utf-8")
     assert "documentclass{beamer}" in slides_text

tests/test_writer.py

@@ -161,6 +161,10 @@ def test_run_iteration_calls_writer_and_emits_writer_done(tmp_path) -> None:
 
     kinds = [k for k, _ in captured]
     assert "writer_done" in kinds
-    paper_text = (project.root_dir / "paper.tex").read_text(encoding="utf-8")
-    # Offline backend emits a marker phrase from the Writer's section bodies.
-    assert "boundary assumption" in paper_text or "two resolutions" in paper_text
+    # Writer emitted the writer_done event with edit-count payload (0 from
+    # RuleBasedBackend, but the structural envelope must be there).
+    writer_payloads = [p for k, p in captured if k == "writer_done"]
+    assert writer_payloads, "writer_done event missing"
+    payload = writer_payloads[-1]
+    assert "edits_proposed" in payload
+    assert "sections_written" in payload

tests/test_writer_diff_mode.py

@@ -235,51 +235,52 @@ def test_writer_can_replace_a_placeholder_emitted_in_an_earlier_iteration(
     assert "monotone\ndecrease" in new_text or "monotone decrease" in new_text
 
 
-def test_writer_falls_back_to_legacy_section_render_when_no_edits(
-    tmp_path: Path,
-) -> None:
-    """If the Writer returns ``{sections: {...}}`` without any edits, the
-    legacy template-render path takes over so older runs keep working."""
+def test_writer_empty_edits_leaves_existing_paper_intact(tmp_path: Path) -> None:
+    """When the Writer returns an empty edits array (genuine "nothing to add
+    this iteration"), _publish must NOT regenerate the paper from the legacy
+    template — that would silently overwrite a placeholder-rich paper with
+    filler prose. Empty edits = paper untouched, full stop."""
     store = ProjectStore(tmp_path)
     project, state = _make_project(tmp_path, store)
     paper_path = project.root_dir / "paper.tex"
-
-    response = json.dumps(
-        {
-            "sections": {
-                "introduction": "Brand-new intro from legacy mode.",
-                "setup": "",
-                "analytical": "",
-                "numerical": "",
-                "literature": "",
-                "discussion": "",
-            }
-        }
+    # Seed a paper with one placeholder we want to verify SURVIVES the
+    # empty-edits round.
+    seed = SEED_PAPER.replace(
+        "\\section{Discussion}",
+        '\\halfseedTODO[data]{id="conv-table", what="convergence table"}\n\n'
+        '\\section{Discussion}',
     )
+    paper_path.write_text(seed, encoding="utf-8")
+
+    response = json.dumps({"edits": []})
     workflow = _make_workflow([response])
 
-    brief = ResearchBrief(problem="Q", objectives=["test"])
+    brief = ResearchBrief(problem="Q")
     curated = CuratedReport(
-        executive_summary="A test.", ranked_artifact_ids=[],
-        synthesis=["x"], open_risks=[], suggested_next_steps=[],
+        executive_summary="", ranked_artifact_ids=[],
+        synthesis=[], open_risks=[], suggested_next_steps=[],
     )
 
     out = workflow._run_writer(
         project=project, brief=brief, curated=curated,
         publish_pool=[], figures=None,
     )
-    assert out.edits == []  # nothing to apply
-    assert out.sections["introduction"]  # legacy shape populated
+    assert out.edits == []
 
-    workflow._publish(
+    result = workflow._publish(
         project, state, brief, curated, [],
-        section_bodies=out.sections,
         writer_edits=out.edits,
     )
+
     new_text = paper_path.read_text(encoding="utf-8")
-    # The Jinja template path was used: distinctive marker = the fixed
-    # \section names from the template.
-    assert "Brand-new intro from legacy mode." in new_text
+    # Placeholder still there, original prose still there, no template
+    # regen junk like the default initial \halfseedTODO[human] starter.
+    assert 'id="conv-table"' in new_text
+    assert "Initial intro prose." in new_text
+    assert result.edits_applied == 0
+    assert result.edits_skipped == 0
+    # Diff summary explicitly notes nothing was proposed.
+    assert "no edits proposed" in result.paper_diff_summary
 
 
 def test_writer_invalid_json_yields_empty_writer_output(tmp_path: Path) -> None: