feat(research): direct campaign injection — bypass LLM for turn delivery

Campaign turns are now injected directly through the SimulationBridge,
bypassing the orchestrator LLM entirely for narrative delivery. This
eliminates the JSON escaping problem (unescaped quotes in dialogue)
that caused 14B models to fail on verbatim turn relay.

Flow:
1. Campaign YAML is loaded with salience/novelty per turn
2. Turns are sent via bridge.send_and_wait() with progress output
3. AUT processes each turn, builds memories, responds
4. THEN the orchestrator LLM starts with an analysis-only goal
   (inspect_aut, record_experiment, finish_simulation)

The LLM never touches the narrative text — it only analyzes the
results after the campaign is complete.

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

Author: dennys246

src/maxim/simulation/orchestrator.py

@@ -245,6 +245,7 @@ def start_simulation_mode(
     sandbox_image: str = "python:3.12-slim",
     sandbox_network: str = "none",
     aut_model: str | None = None,
+    pre_campaign_turns: list[dict[str, Any]] | None = None,
 ) -> SimulationResult:
     """Boot simulation mode: AUT + orchestrator + stdin reader.
 
@@ -887,6 +888,54 @@ def _aut_worker() -> None:
     aut_thread = threading.Thread(target=_aut_worker, name="sim.aut", daemon=True)
     aut_thread.start()
 
+    # ── Pre-campaign: inject turns directly through bridge ───────────────
+    # When campaign turns are provided, we bypass the orchestrator LLM for
+    # turn delivery.  The bridge sends each turn to the AUT as a raw percept,
+    # waits for the response, and records the result.  This avoids JSON
+    # escaping issues with narrative dialogue and ensures verbatim delivery.
+    campaign_results: list[dict[str, Any]] = []
+    if pre_campaign_turns:
+        import time as _pc_time
+
+        print(f"\n  Delivering {len(pre_campaign_turns)} campaign turns directly to AUT...")
+        # Give AUT a moment to start up
+        _pc_time.sleep(1.0)
+        for i, turn in enumerate(pre_campaign_turns, 1):
+            text = turn.get("text", "")
+            phase = turn.get("phase", "")
+            sal = turn.get("salience", 0.8)
+            nov = turn.get("novelty", 0.7)
+            phase_label = f" [{phase}]" if phase else ""
+            print(f"  Turn {i}/{len(pre_campaign_turns)}{phase_label}: sending ({len(text)} chars)...")
+            try:
+                result = bridge.send_and_wait(text, salience=sal, novelty=nov)
+                actions = [a.tool_name for a in result.get("actions", [])]
+                blocked = len(result.get("blocked", []))
+                response = result.get("response", "")
+                resp_preview = (
+                    (response[:80] + "...") if response and len(response) > 80 else (response or "(no verbal response)")
+                )
+                print(
+                    f"    AUT: {len(actions)} action(s) {actions}, {blocked} blocked, {result.get('duration_ms', 0):.0f}ms"
+                )
+                print(f"    Response: {resp_preview}")
+                campaign_results.append(
+                    {
+                        "turn": i,
+                        "phase": phase,
+                        "text_len": len(text),
+                        "actions": actions,
+                        "blocked": blocked,
+                        "response": response,
+                        "timed_out": result.get("timed_out", False),
+                        "duration_ms": result.get("duration_ms", 0),
+                    }
+                )
+            except Exception as e:
+                logger.warning("Campaign turn %d failed: %s", i, e)
+                campaign_results.append({"turn": i, "phase": phase, "error": str(e)})
+        print(f"  Campaign delivery complete: {len(campaign_results)} turns delivered\n")
+
     # ── Inject initial goal (or resume context) into orchestrator ────────
     if resume_session:
         resume_data = _load_resume_context(resume_session)

src/maxim/simulation/research_orchestrator.py

@@ -124,52 +124,46 @@ def start_research_mode(
                             "phase": p.get("metadata", {}).get("phase", ""),
                             "role": p.get("metadata", {}).get("experiment_role", ""),
                             "tag": p.get("metadata", {}).get("scenario_tag", ""),
+                            "salience": p.get("salience", 0.8),
+                            "novelty": p.get("novelty", 0.7),
                         }
                     )
             print(f"  Loaded {len(campaign_turns)} campaign turns from {campaign}")
         except Exception as e:
             logger.warning("Failed to load campaign YAML: %s", e)
 
-    # Build the researcher goal with concrete campaign steps
+    # Build the researcher goal — campaign turns are injected directly
+    # through the bridge (bypassing the LLM), so the orchestrator only
+    # needs to do post-campaign analysis.
     researcher_goal = goal
     if campaign_turns:
-        turn_lines = []
-        for i, turn in enumerate(campaign_turns, 1):
-            phase_label = f" [{turn['phase']}]" if turn["phase"] else ""
-            # Show full text (up to 500 chars) so the LLM has the complete narrative
-            turn_lines.append(f"--- TURN {i}{phase_label} ---\n{turn['text'][:500]}")
-        turns_block = "\n\n".join(turn_lines)
         researcher_goal = (
             f"{goal}\n\n"
-            f"CAMPAIGN PROTOCOL\n"
-            f"=================\n"
-            f"You MUST deliver the following narrative turns to the AUT, in order.\n"
-            f'For each turn, call: send_message(text="<the narrative text below>")\n\n'
-            f"IMPORTANT RULES:\n"
-            f"- Send the narrative text VERBATIM — do NOT paraphrase, summarize, or adapt it.\n"
-            f"- Do NOT invent your own probes or adversarial variations.\n"
-            f"- Do NOT skip turns or reorder them.\n"
-            f"- Wait for the AUT response after each turn before sending the next.\n\n"
-            f"{turns_block}\n\n"
-            f"--- END OF CAMPAIGN TURNS ---\n\n"
-            f"After ALL {len(campaign_turns)} turns are sent and responses collected:\n"
-            f"1. Use inspect_aut(query='memory_recall', params={{'keyword': 'Verath'}}) to check memory survival\n"
-            f"2. Use inspect_aut(query='system_stats') for graph topology\n"
-            f"3. Record results with record_experiment\n"
-            f"4. Call finish_simulation with your findings"
+            f"CAMPAIGN COMPLETE — {len(campaign_turns)} narrative turns were delivered directly to the AUT.\n"
+            f"The campaign tested memory recall under narrative interference.\n\n"
+            f"YOUR TASK (analysis only — do NOT send any more narrative turns):\n"
+            f"1. Use inspect_aut(query='memory_recall', params={{'keyword': 'Verath'}}) to check if the seed memory survived\n"
+            f"2. Use inspect_aut(query='system_stats') for graph topology and memory count\n"
+            f"3. Use observe_actions to review the AUT's behavior during the campaign\n"
+            f"4. Record your findings with record_experiment (hypothesis, method, result, conclusion)\n"
+            f"5. Call finish_simulation with your analysis"
         )
     elif campaign:
         researcher_goal = f"{goal}\n\nCampaign file: {campaign} (failed to load — run manually with send_message)"
 
-    # Run the researcher via the existing simulation orchestrator
+    # Run the researcher via the existing simulation orchestrator.
+    # Campaign turns are injected directly through the bridge before the
+    # orchestrator LLM starts, ensuring verbatim delivery without JSON
+    # escaping issues.
     sim_result = start_simulation_mode(
         goal=researcher_goal,
         persona="researcher",
         max_turns=max_turns,
         debug=debug,
         sandbox_backend=sandbox_backend,
         aut_model=aut_model,
-        no_sim_env=True,  # Research mode doesn't need pain-triggering files
+        no_sim_env=True,
+        pre_campaign_turns=campaign_turns if campaign_turns else None,
     )
 
     # The experiment log was populated by the researcher's record_experiment calls