feat(fase1): spike B - magentic unbounded + concurrent state isolation [skip-docs]

spikes/b_footguns.py

@@ -0,0 +1,122 @@
+"""Spike B — Magentic unbounded-termination footgun (G1/B4) + fan-out state
+isolation (G2/B7).
+
+Driving the GA builders with the fake client (de-risked by the Step 2 smoke) *is*
+the experiment here — no live LLM, so this whole spike runs in the quality gate.
+
+(a) **Magentic unbounded (G1/B4).** A `StandardMagenticManager` whose progress ledger
+    always says "not satisfied / progress being made" never finalizes. With
+    `max_round_count=None` it would loop forever; we drive it under the shared harness
+    round/iteration guard and confirm the guard is what stops it (it does NOT
+    self-terminate). With an explicit `max_round_count` it terminates cleanly.
+
+(b) **Fan-out state isolation (G2/B7).** Reusing ONE workflow instance across the three
+    reference projects bleeds state (the shared fake clients accumulate calls); a FRESH
+    instance per run — via `fresh_workflow()` — shows zero bleed.
+
+Token use: 0 — no live LLM (the fake client's "tokens" are word-counts of canned replies).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import warnings
+
+from agent_framework import Agent
+from agent_framework.orchestrations import (
+    ConcurrentBuilder,
+    MagenticBuilder,
+    StandardMagenticManager,
+)
+
+from spikes._harness import Budget, BudgetExceeded, FakeChatClient, TokenMeter, fake_agent
+
+# Cutting an *instrumented* Magentic stream short (the only way to observe an unbounded
+# run) makes OpenTelemetry log a benign "Failed to detach context" on generator close.
+# It is cosmetic — silence it so the spike output stays readable. (Recorded in findings-b.)
+logging.getLogger("opentelemetry.context").setLevel(logging.CRITICAL)
+
+# A progress ledger that never reports satisfaction and always claims progress — so the
+# manager has no natural reason to stop. next_speaker points at the single worker.
+_NEVER_SATISFIED_LEDGER = json.dumps(
+    {
+        "is_request_satisfied": {"reason": "not yet", "answer": False},
+        "is_in_loop": {"reason": "no", "answer": False},
+        "is_progress_being_made": {"reason": "yes", "answer": True},
+        "next_speaker": {"reason": "worker should act", "answer": "worker"},
+        "instruction_or_question": {"reason": "continue", "answer": "Keep working."},
+    }
+)
+
+
+def _magentic(max_round_count: int | None) -> object:
+    """Build a Magentic workflow whose manager never self-finalizes."""
+    manager = StandardMagenticManager(
+        agent=Agent(FakeChatClient(default_reply=_NEVER_SATISFIED_LEDGER), "manager", name="manager"),
+        max_round_count=max_round_count,
+    )
+    worker = Agent(FakeChatClient(default_reply="worker did some work"), "worker", name="worker")
+    return MagenticBuilder(participants=[worker], manager=manager).build()
+
+
+async def unbounded_magentic_self_terminates(*, guard_rounds: int = 10) -> bool:
+    """Drive an unbounded (`max_round_count=None`) Magentic under the harness guard.
+
+    Returns ``True`` if the workflow stopped on its own, ``False`` if the external guard
+    had to stop it. The footgun (G1/B4) is confirmed when this returns ``False``.
+    """
+    workflow = _magentic(None)
+    meter = TokenMeter(Budget(max_tokens=10**9, max_rounds=guard_rounds))
+    guard_fired = False
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", RuntimeWarning)
+        async for _event in workflow.run("Do a never-ending task.", stream=True):
+            try:
+                meter.tick_round()  # one tick per orchestration event (iteration guard)
+            except BudgetExceeded:
+                guard_fired = True
+                break
+    return not guard_fired
+
+
+async def bounded_magentic_terminates(*, max_round_count: int = 2) -> bool:
+    """An explicit `max_round_count` makes the same never-satisfied manager stop cleanly.
+
+    Returns ``True`` when the workflow runs to completion and yields an output.
+    """
+    workflow = _magentic(max_round_count)
+    result = await workflow.run("Do a bounded task.")
+    return len(result.get_outputs()) >= 1
+
+
+def fresh_workflow() -> tuple[object, tuple[FakeChatClient, FakeChatClient]]:
+    """B7 mitigation: a factory that builds a FRESH fan-out workflow with FRESH clients
+    every call, so no state survives between runs."""
+    c1 = FakeChatClient(default_reply="participant one view")
+    c2 = FakeChatClient(default_reply="participant two view")
+    workflow = ConcurrentBuilder(
+        participants=[fake_agent(c1, "w1"), fake_agent(c2, "w2")]
+    ).build()
+    return workflow, (c1, c2)
+
+
+async def shared_instance_max_calls(project_ids: list[str]) -> int:
+    """Reuse ONE fan-out instance across every project — state bleeds: the shared clients
+    accumulate calls across runs. Returns the max per-client call count (== len once
+    bled)."""
+    workflow, clients = fresh_workflow()
+    for pid in project_ids:
+        await workflow.run(f"Evaluate project {pid}.")
+    return max(c.call_count for c in clients)
+
+
+async def fresh_instance_call_counts(project_ids: list[str]) -> list[int]:
+    """A FRESH instance per project — zero bleed: every run's clients see exactly one
+    call. Returns the per-run max call count (each should be 1)."""
+    counts: list[int] = []
+    for pid in project_ids:
+        workflow, clients = fresh_workflow()
+        await workflow.run(f"Evaluate project {pid}.")
+        counts.append(max(c.call_count for c in clients))
+    return counts