┌─────────────────────────────────────────┐
                    │        Router  (resident, always on)     │
                    │  · sees all messages (GitHub / Feishu)   │
                    │  · judges: worth acting on? authorized?  │
                    │  · opens tickets, dispatches, never acts │
                    │  · lightweight model is enough           │
                    └───────────────┬─────────────────────────┘
                                    │  dispatch (isolated session + dir)
              ┌─────────────────────┼─────────────────────┐
              ▼                     ▼                     ▼
     ┌─────────────────┐   ┌─────────────────┐   ┌─────────────────┐
     │  Worker #1      │   │  Worker #2      │   │  Worker #3      │
     │  own context    │   │  own context    │   │  own context    │
     │  own directory  │   │  own directory  │   │  own directory  │
     │  own branch     │   │  own branch     │   │  own branch     │
     │  strong model   │   │  strong model   │   │  strong model   │
     └────────┬────────┘   └────────┬────────┘   └────────┬────────┘
              │                     │                     │
              └─────────────────────┼─────────────────────┘
                                    ▼
                    ┌─────────────────────────────────────────┐
                    │  Event bus + subscription direct-pass    │
                    │  (Router reacts to new events instantly) │
                    └─────────────────────────────────────────┘
                                    │
                    ┌───────────────▼─────────────────────────┐
                    │  External Watchdog (hourly self-check)   │
                    │  · restart if service dies               │
                    │  · keeps the whole thing alive           │
                    └─────────────────────────────────────────┘

# Why context isolation matters: single session vs. two-layer
def context_pollution(single_session_msgs=300, work_requests=20):
    """
    In a single session, all messages share one context window.
    Interleaved work requests pollute each other's context.
    """
    # Single session: every message competes for the same window
    single_ctx_load = single_session_msgs  # all in one window

    # Two-layer: Router sees all, each Worker sees only its own ticket
    router_ctx_load = single_session_msgs
    worker_ctx_load = single_session_msgs / max(work_requests, 1)  # roughly

    return {
        "single-session context load": f"{single_ctx_load} msgs",
        "router context load": f"{router_ctx_load} msgs (but shallow)",
        "per-worker context load": f"{worker_ctx_load:.1f} msgs (deep)",
        "pollution risk (single)": "high — tasks interleave",
        "pollution risk (two-layer)": "low — tasks isolated",
    }

for k, v in context_pollution().items():
    print(f"  {k:32s} {v}")

# Channel-aware output: the same agent, two very different formats
def channel_policy():
    return {
        "IM / group chat": {
            "density": "low",
            "goal": "minimize interruption",
            "hard rule": "single reply <= 100 words; channel rejects longer",
            "banned": "long sentences, semicolon chains, lists, rapid-fire multiple messages",
            "when to speak": "only when a decision or acceptance is needed",
        },
        "GitHub PR / email / docs": {
            "density": "high",
            "goal": "structured async delivery",
            "hard rule": "full problem background, change description, verification result",
            "banned": "vague one-liners",
            "when to speak": "at delivery time, once, completely",
        },
    }

for channel, d in channel_policy().items():
    print(f"\n[{channel}]")
    for k, v in d.items():
        print(f"  {k:16s}: {v}")

# The ablation: completion time vs. token cost
def ablation_results():
    return [
        {
            "scheme": "Super-agent (two-layer + direct-pass)",
            "p50_min": 12.4,
            "p95_min": 15.7,
            "cached_tokens_M": 23.23,
        },
        {
            "scheme": "Super-agent, direct-pass removed",
            "p50_min": 12.6,
            "p95_min": 15.5,
            "cached_tokens_M": 31.77,
        },
        {
            "scheme": "Single session + Subagent tool (neutral prompt)",
            "p50_min": 20.4,
            "p95_min": 29.5,
            "cached_tokens_M": 6.05,
        },
        {
            "scheme": "Single session + Subagent tool (delegation-first prompt)",
            "p50_min": 13.8,
            "p95_min": 29.0,
            "cached_tokens_M": 10.82,
        },
    ]

print(f"{'Scheme':<52}{'p50':<8}{'p95':<8}{'Cached tok (M)'}")
print("-" * 82)
for r in ablation_results():
    print(f"{r['scheme']:<52}{r['p50_min']:<8}{r['p95_min']:<8}{r['cached_tokens_M']}")

print("\nToken ratio vs single-session:")
base = 6.05
for r in ablation_results():
    print(f"  {r['scheme'][:48]:<50}{r['cached_tokens_M']/base:.1f}x")

# Why prompts move the mean but not the tail
def tail_analysis():
    """
    Tail latency comes from the rare case where the model decides
    "I'll just do this myself" — and then gets interrupted repeatedly.
    """
    scenarios = {
        "neutral prompt": {
            "delegation rate": "0/5 (0%)",
            "p50": 20.4,
            "p95": 29.5,
            "tail cause": "everything runs in main session",
        },
        "delegation-first prompt": {
            "delegation rate": "4/5 (80%)",
            "p50": 13.8,
            "p95": 29.0,
            "tail cause": "the 1/5 self-execution case becomes the tail",
        },
        "two-layer architecture": {
            "delegation rate": "enforced by design (100%)",
            "p50": 12.4,
            "p95": 15.7,
            "tail cause": "no self-execution path exists",
        },
    }

    print(f"{'Scenario':<28}{'Delegation':<26}{'p50':<8}{'p95':<8}{'Tail cause'}")
    print("-" * 108)
    for name, d in scenarios.items():
        print(f"{name:<28}{d['delegation rate']:<26}{d['p50']:<8}{d['p95']:<8}{d['tail cause']}")

tail_analysis()

# What 4x tokens actually costs
def token_cost():
    """
    DeepSeek-V4.1-Flash pricing (CNY per million tokens).
    Off-peak cache hit: 0.02; peak cache hit: 0.04
    Cache miss input: 1.0; output: 4.0
    """
    extra_tokens_M = 23.23 - 6.05  # 17.18M extra cached tokens
    off_peak = extra_tokens_M * 0.02
    peak = extra_tokens_M * 0.04

    return {
        "extra cached tokens": f"{extra_tokens_M:.2f}M",
        "extra cost off-peak": f"{off_peak:.2f} CNY",
        "extra cost peak": f"{peak:.2f} CNY",
        "verdict": "the 4x token multiplier is cheap ONLY because cache hits cost almost nothing",
    }

for k, v in token_cost().items():
    print(f"  {k:26s} {v}")

# Polling vs. event direct-pass: why polling costs tokens
def polling_cost(events_per_min=1, poll_interval_s=5, minutes=60, ctx_tokens=15000):
    """
    Polling re-reads context every time it checks, even when nothing happened.
    """
    polls = minutes * 60 / poll_interval_s
    wasted_polls = max(polls - events_per_min * minutes, 0)
    wasted_tokens = wasted_polls * ctx_tokens

    return {
        "polls in an hour": f"{polls:.0f}",
        "actual events": f"{events_per_min * minutes}",
        "wasted polls": f"{wasted_polls:.0f}",
        "wasted tokens": f"{wasted_tokens/1e6:.2f}M",
        "direct-pass alternative": "0 wasted polls — Router is pushed only on real events",
    }

for k, v in polling_cost().items():
    print(f"  {k:26s} {v}")

# Router batching: more load, cheaper per decision
def router_batching():
    return {
        "trigger rate (per min)": ["~1", "~40"],
        "average batch size": [1.0, 2.8],
        "single request latency (s)": [2.5, 3.9],
        "per-decision inference time (s)": [6.4, 1.6],
    }

data = router_batching()
keys = list(data.keys())
print(f"{'Metric':<34}{'Low load':<14}{'High load':<14}{'Change'}")
print("-" * 76)
for i, k in enumerate(keys):
    if i == 0:
        print(f"{k:<34}{data[k][0]:<14}{data[k][1]:<14}{'40x'}")
    elif i == 3:
        print(f"{k:<34}{data[k][0]:<14}{data[k][1]:<14}{'-75%'}")
    else:
        print(f"{k:<34}{data[k][0]:<14}{data[k][1]:<14}{data[k][1]/data[k][0]:.2f}x")

print("\nKey insight: latency grows 1.56x while batch grows 2.8x —")
print("per-decision cost falls because one inference serves 2.8 decisions.")

# Should you shard the Router? The tradeoff
def sharding_tradeoff():
    return {
        "single router": {
            "throughput ceiling": "not yet hit at ~40 triggers/min",
            "global context": "preserved — sees all events",
            "decision quality": "high (full picture)",
            "failure mode": "single point of failure (mitigated by watchdog)",
        },
        "sharded routers": {
            "throughput ceiling": "much higher",
            "global context": "lost — each shard sees a slice",
            "decision quality": "lower (partial picture)",
            "failure mode": "cross-shard coordination complexity",
        },
        "verdict": "at current scale, sharding costs more than it gains",
    }

for k, v in sharding_tradeoff().items():
    if isinstance(v, dict):
        print(f"\n[{k}]")
        for kk, vv in v.items():
            print(f"  {kk:22s}: {vv}")
    else:
        print(f"\n{k}: {v}")

# Attention budget: why verbosity is a real cost
def attention_cost(team_size=10, messages_per_day=30, words_per_message=300,
                   read_speed_wpm=250):
    """
    Each agent message costs every team member reading time.
    """
    read_min_per_msg = words_per_message / read_speed_wpm
    daily_min_per_person = messages_per_day * read_min_per_msg
    team_daily_hours = daily_min_per_person * team_size / 60
    team_yearly_hours = team_daily_hours * 250

    # With the 100-word cap
    capped_words = 100
    capped_min = capped_words / read_speed_wpm
    capped_daily = messages_per_day * capped_min
    capped_team_hours = capped_daily * team_size / 60
    capped_yearly = capped_team_hours * 250

    return {
        "verbose (300 words/msg)": f"{team_yearly_hours:.0f} person-hours/year",
        "capped (100 words/msg)": f"{capped_yearly:.0f} person-hours/year",
        "saved": f"{team_yearly_hours - capped_yearly:.0f} person-hours/year",
    }

for k, v in attention_cost().items():
    print(f"  {k:28s} {v}")

# Prompt rule vs. infrastructure rule
def enforcement_comparison():
    return {
        "prompt-level rule": {
            "example": "please keep replies under 100 words",
            "enforcement": "model may ignore, especially under long context",
            "failure mode": "silent — nobody notices until it's habitual",
            "reliability": "low",
        },
        "infrastructure-level rule": {
            "example": "channel rejects messages longer than 100 words",
            "enforcement": "mechanically guaranteed",
            "failure mode": "loud — send fails, visible immediately",
            "reliability": "high",
        },
    }

for level, d in enforcement_comparison().items():
    print(f"\n[{level}]")
    for k, v in d.items():
        print(f"  {k:16s}: {v}")

# Real-world measured costs from a hands-on test
def measured_costs():
    return [
        ("installation", "10 min", 0.14),
        ("fix README typo", "2 min", 0.04),
        ("fix button typo + before/after screenshots", "6 min", 0.21),
        ("fix a small bug", "7 min", 0.18),
        ("cannot reproduce, silently gives up", "5 min", 0.12),
    ]

print(f"{'Task':<44}{'Time':<10}{'Cost (CNY)'}")
print("-" * 66)
total_time = 0
total_cost = 0
for task, t, c in measured_costs():
    print(f"{task:<44}{t:<10}{c}")
    total_cost += c
print("-" * 66)
print(f"{'TOTAL':<44}{'30 min':<10}{total_cost:.2f}")

print("\nPer-task average:", f"{total_cost/5:.2f} CNY")

# What does 0.18 CNY per bug fix mean economically?
def economics(fix_cost_cny=0.18, engineer_hourly_cny=200):
    """
    Compare agent cost against engineer time, for a trivial bug.
    """
    # A trivial bug: engineer takes ~15 min including context switching
    engineer_min = 15
    engineer_cost = engineer_hourly_cny * engineer_min / 60

    return {
        "agent cost per fix": f"{fix_cost_cny:.2f} CNY",
        "engineer cost per fix": f"{engineer_cost:.2f} CNY",
        "cost ratio": f"{engineer_cost/fix_cost_cny:.0f}x cheaper",
        "caveat": "only holds for bugs the agent can actually fix",
    }

for k, v in economics().items():
    print(f"  {k:24s} {v}")

# The value of giving up: expected cost with and without a stop condition
def giveup_value(p_reproducible=0.6, cost_try=0.12, cost_thrash=2.50,
                 p_bad_fix_if_thrash=0.35, cost_bad_fix=15.0):
    """
    Without a stop condition, the agent keeps trying and may submit a wrong fix.
    """
    # With stop condition
    expected_with = cost_try + (1 - p_reproducible) * 0

    # Without stop condition: keeps thrashing, may produce a bad PR
    expected_without = (
        cost_try
        + (1 - p_reproducible) * cost_thrash
        + (1 - p_reproducible) * p_bad_fix_if_thrash * cost_bad_fix
    )

    return {
        "expected cost with stop condition": f"{expected_with:.2f} CNY",
        "expected cost without": f"{expected_without:.2f} CNY",
        "saved": f"{expected_without - expected_with:.2f} CNY",
        "bigger point": "a wrong PR costs far more than the tokens saved by trying harder",
    }

for k, v in giveup_value().items():
    print(f"  {k:38s} {v}")