You are a constitutional council ranking individual git commits for ownership allocation. Compare these two commits. Decide which contributed more lasting value to the project. Judge substance, not spectacle: - Prefer correct, lasting design and real bugfixes over churn, formatting, renames, or generated noise. - Prefer clarity and necessity over sheer line count. A small precise change can beat a large diffuse one. - Do not favor a side merely because its patch is longer or noisier. - Weight what the change does for the project, not the contributor's name. Return ONLY a JSON object: {"winner": "A" or "B", "ratio": "N:M", "explanation": "..."} The explanation must cite concrete differences in the patches (1-3 sentences). Side A — contributor: tommy-mor Side A — commit message: [c7ef287e] Rank every eligible commit with the LLM council. Stop short-circuiting on a single contributor; pairwise-sort commits, roll scores up for emission payouts, and surface commit rankings on epoch pages. Co-authored-by: Cursor Side A — unified diff (full patch): diff --git a/constitution.py b/constitution.py index 26ba130e885e0e69fb7874ca5c3f07f42100a150..71fc46b4c9a4d7a9ea7bf319860b0db1acc4a673 100644 --- a/constitution.py +++ b/constitution.py @@ -503,20 +503,22 @@ def _epochs_in_ledger() -> list[int]: def build_pairwise_prompt(side_a: dict, side_b: dict) -> str: - return f"""You are ranking contributions to an open source project. -Compare these two sides (each may be one or more commits). Decide which side contributed more. + return f"""You are ranking individual git commits to an open source project. +Compare these two commits. Decide which commit contributed more. Return ONLY a JSON object: {{"winner": "A" or "B", "ratio": "N:M", "explanation": "..."}} -Side A — commit messages: +Side A — contributor: {side_a.get('contributor', '?')} +Side A — commit message: {side_a['message']} -Side A — unified diffs (full patches): +Side A — unified diff (full patch): {side_a['diff']} -Side B — commit messages: +Side B — contributor: {side_b.get('contributor', '?')} +Side B — commit message: {side_b['message']} -Side B — unified diffs (full patches): +Side B — unified diff (full patch): {side_b['diff']}""" @@ -1518,16 +1520,28 @@ async def broadcast_js(js: str): await queue.put(js) -def _author_side_for_llm(author: str, author_commits: dict) -> dict: - cs = author_commits[author] +def _commit_side_for_llm(row: dict) -> dict: + oid = row["oid"] + short = oid.split(":", 1)[1][:8] if ":" in oid else oid[:8] return { - "message": "\n".join(f"[{c['sha']}] {c['message']}" for c in cs), - "diff": "\n\n".join(f"=== {c['sha']} ===\n{c['diff']}" for c in cs), - "commit_ids": [c["commit_id"] for c in cs], - "contributor": author, + "message": f"[{short}] {row['message']}", + "diff": row["patch"] or "", + "commit_id": commit_id_for_oid(oid), + "contributor": row["contributor"], + "oid": oid, } +def _rollup_contributor_scores( + ordered: list[dict], commit_scores: list[Decimal] +) -> dict[str, Decimal]: + totals: dict[str, Decimal] = {} + for row, score in zip(ordered, commit_scores): + contributor = row["contributor"] + totals[contributor] = totals.get(contributor, Decimal("0")) + score + return totals + + def _find_judgment(comparison_id: str, model_id: str) -> dict | None: for e in evidence_by_kind("llm.judgment"): p = e.payload @@ -1546,101 +1560,106 @@ def _find_ranking_models(ranking_run_id: str) -> list[str] | None: async def rank_commits(commits: list[dict], *, epoch: int = -1): + """Pairwise-rank every eligible commit; roll scores up to contributors.""" if not commits: return {}, [], {"ranking_run_id": "", "ranking_event_id": ""} - commit_ids = sorted(commit_id_for_oid(row["oid"]) for row in commits) + ordered = sorted(commits, key=lambda r: r["oid"]) + commit_ids = [commit_id_for_oid(row["oid"]) for row in ordered] ranking_run_id = _content_id("rank", { "epoch": epoch, - "commit_ids": commit_ids, + "commit_ids": sorted(commit_ids), }) - contributors = sorted(set(c["contributor"] for c in commits)) + contributors = sorted({c["contributor"] for c in ordered}) - if len(contributors) == 1: + # Nothing to compare: a single commit (not a single contributor). + if len(ordered) == 1: await append_evidence(epoch, "ranking.started", { "ranking_run_id": ranking_run_id, "commit_ids": commit_ids, "contributors": contributors, "models": [], - "summary": f"ranking epoch {epoch}: single contributor", + "summary": f"ranking epoch {epoch}: single commit", }) - ranking = {contributors[0]: Decimal("1")} + commit_ranking = {commit_ids[0]: "1"} + contributor_ranking = {ordered[0]["contributor"]: Decimal("1")} completed = await append_evidence(epoch, "ranking.completed", { "ranking_run_id": ranking_run_id, "models": [], - "ranking": {contributors[0]: "1"}, + "commit_ranking": commit_ranking, + "contributor_ranking": {ordered[0]["contributor"]: "1"}, + "ranking": {ordered[0]["contributor"]: "1"}, "judgment_ids": [], - "summary": f"Only {contributors[0]} is eligible; rank is 1.0", + "summary": f"Only one eligible commit; {ordered[0]['contributor']} rank 1.0", }) await broadcast_audit( "ranking", - f"Only {contributors[0]} is eligible; rank is 1.0", + f"Only one eligible commit; {ordered[0]['contributor']} rank 1.0", progress=90, phase="finalizing", evidence_event_id=completed.event_id, evidence_url=_evidence_url("event", completed.event_id), links={"epoch": _evidence_url("epoch", str(epoch))}, ) - return ranking, [], { + return contributor_ranking, [], { "ranking_run_id": ranking_run_id, "ranking_event_id": completed.event_id, } if not (OPENROUTER_API_KEY or "").strip(): raise RuntimeError( - "OPENROUTER_API_KEY is required when multiple contributors need ranking" + "OPENROUTER_API_KEY is required when multiple commits need ranking" ) models = _find_ranking_models(ranking_run_id) if models is None: models = await fetch_top_models(n=3) if not models: - raise RuntimeError("no council models available for contributor ranking") + raise RuntimeError("no council models available for commit ranking") await append_evidence(epoch, "ranking.started", { "ranking_run_id": ranking_run_id, "commit_ids": commit_ids, "contributors": contributors, "models": models, - "summary": f"Council selected: {', '.join(models)}", + "summary": ( + f"Council selected: {', '.join(models)} — " + f"{len(ordered)} commits" + ), }) await broadcast_audit( "council", - f"Council selected: {', '.join(models)}", + f"Council selected: {', '.join(models)} — ranking {len(ordered)} commits", progress=35, phase="ranking", ) await broadcast_js(exec_event(Three[Selector("#emission-log")][PREPEND][ - ["div.log-council", f"Council: {', '.join(models)} — {len(commits)} commits"] + ["div.log-council", + f"Council: {', '.join(models)} — {len(ordered)} commits"] ])) - authors = contributors - author_commits = {a: [] for a in authors} - for row in sorted(commits, key=lambda r: r["oid"]): - author_commits[row["contributor"]].append({ - "message": row["message"], - "sha": row["oid"].split(":", 1)[1][:8], - "diff": row["patch"], - "commit_id": commit_id_for_oid(row["oid"]), - }) - + sides = [_commit_side_for_llm(row) for row in ordered] judgment_ids: list[str] = [] async def compare_fn(i, j): - a1, a2 = authors[i], authors[j] - side_a = _author_side_for_llm(a1, author_commits) - side_b = _author_side_for_llm(a2, author_commits) + side_a, side_b = sides[i], sides[j] + label_a = f"{side_a['commit_id'][:16]} ({side_a['contributor']})" + label_b = f"{side_b['commit_id'][:16]} ({side_b['contributor']})" prompt = build_pairwise_prompt(side_a, side_b) comparison_material = { "ranking_run_id": ranking_run_id, "side_a": { - "contributor": a1, - "commit_ids": side_a["commit_ids"], + "contributor": side_a["contributor"], + "commit_id": side_a["commit_id"], + "commit_ids": [side_a["commit_id"]], + "oid": side_a["oid"], "message": _bytes_blob(side_a["message"]), "diff": _bytes_blob(side_a["diff"]), }, "side_b": { - "contributor": a2, - "commit_ids": side_b["commit_ids"], + "contributor": side_b["contributor"], + "commit_id": side_b["commit_id"], + "commit_ids": [side_b["commit_id"]], + "oid": side_b["oid"], "message": _bytes_blob(side_b["message"]), "diff": _bytes_blob(side_b["diff"]), }, @@ -1650,22 +1669,24 @@ async def rank_commits(commits: list[dict], *, epoch: int = -1): comparison_material = { **comparison_material, "comparison_id": comparison_id, - "summary": f"Comparing {a1} with {a2}", + "summary": f"Comparing {label_a} with {label_b}", } cmp_ev = await append_evidence(epoch, "comparison.input", comparison_material) await broadcast_audit( "comparison", - f"Comparing {a1} with {a2}", + f"Comparing commits {label_a} vs {label_b}", phase="ranking", evidence_event_id=cmp_ev.event_id, evidence_url=_evidence_url("comparison", comparison_id), links={ "comparison": _evidence_url("comparison", comparison_id), + "commit_a": _evidence_url("commit", side_a["commit_id"]), + "commit_b": _evidence_url("commit", side_b["commit_id"]), "epoch": _evidence_url("epoch", str(epoch)), }, ) await broadcast_js(exec_event(Three[Selector("#emission-status")][MORPH][ - ["div#emission-status", f"Comparing {a1} vs {a2}…"] + ["div#emission-status", f"Comparing {label_a} vs {label_b}…"] ])) results = [] for model in models: @@ -1697,9 +1718,15 @@ async def rank_commits(commits: list[dict], *, epoch: int = -1): jud_id = (existing or _find_judgment(comparison_id, model) or {}).get( "judgment_id" ) + win_label = ( + f"{sides[w]['commit_id'][:16]} ({sides[w]['contributor']})" + ) + lose_label = ( + f"{sides[l]['commit_id'][:16]} ({sides[l]['contributor']})" + ) await broadcast_audit( "vote", - f"{model}: {authors[w]} over {authors[l]} ({result['ratio']})", + f"{model}: {win_label} over {lose_label} ({result['ratio']})", phase="ranking", evidence_url=( _evidence_url("judgment", jud_id) if jud_id else None @@ -1714,8 +1741,8 @@ async def rank_commits(commits: list[dict], *, epoch: int = -1): await broadcast_js(exec_event(Three[Selector("#emission-log")][PREPEND][ ["div.log-vote", ["span.model", model], " — ", - ["span.winner", authors[w]], f" beat ", - ["span.loser", authors[l]], f" ({result['ratio']}) ", + ["span.winner", win_label], f" beat ", + ["span.loser", lose_label], f" ({result['ratio']}) ", ["span.explanation", result["explanation"]], ] ])) @@ -1745,24 +1772,46 @@ async def rank_commits(commits: list[dict], *, epoch: int = -1): ["div#emission-status", label] ])) - pairs = await pairwise_rank(len(authors), compare_fn, progress_fn) + pairs = await pairwise_rank(len(ordered), compare_fn, progress_fn) if not pairs: - ranking = {authors[0]: Decimal("1")} if authors else {} + commit_score_list = [Decimal("1")] else: scores = rank_centrality(pairs) - ranking = {authors[i]: Decimal(str(scores[i])) for i in range(len(authors))} - ranking_rows = sorted(ranking.items(), key=lambda x: x[1], reverse=True) + commit_score_list = [Decimal(str(scores[i])) for i in range(len(ordered))] + + commit_ranking = { + commit_ids[i]: str(commit_score_list[i]) for i in range(len(ordered)) + } + contributor_totals = _rollup_contributor_scores(ordered, commit_score_list) + contrib_rows = sorted( + contributor_totals.items(), key=lambda x: x[1], reverse=True + ) + commit_rows = sorted( + ((commit_ids[i], commit_score_list[i], ordered[i]["contributor"]) + for i in range(len(ordered))), + key=lambda x: x[1], + reverse=True, + ) completed = await append_evidence(epoch, "ranking.completed", { "ranking_run_id": ranking_run_id, "models": models, - "ranking": {a: str(s) for a, s in ranking_rows}, + "commit_ranking": commit_ranking, + "contributor_ranking": {a: str(s) for a, s in contrib_rows}, + "ranking": {a: str(s) for a, s in contrib_rows}, "judgment_ids": judgment_ids, - "summary": "Ranking: " + ", ".join(f"{a} {s:.4f}" for a, s in ranking_rows), + "summary": ( + "Commit ranking: " + + ", ".join( + f"{cid[:16]}={float(s):.4f}" for cid, s, _ in commit_rows[:12] + ) + + ("…" if len(commit_rows) > 12 else "") + ), }) await broadcast_audit( "ranking", - "Ranking: " + ", ".join(f"{a} {s:.4f}" for a, s in ranking_rows), + "Contributor rollup: " + + ", ".join(f"{a} {s:.4f}" for a, s in contrib_rows), progress=90, phase="finalizing", evidence_event_id=completed.event_id, @@ -1772,10 +1821,10 @@ async def rank_commits(commits: list[dict], *, epoch: int = -1): await broadcast_js(exec_event(Three[Selector("#emission-log")][PREPEND][ ["div.log-ranking", ["b", "Ranking: "], - *[["span.rank-entry", f"{a} {float(s):.3f} "] for a, s in ranking_rows], + *[["span.rank-entry", f"{a} {float(s):.3f} "] for a, s in contrib_rows], ] ])) - return ranking, models, { + return contributor_totals, models, { "ranking_run_id": ranking_run_id, "ranking_event_id": completed.event_id, } @@ -2352,6 +2401,23 @@ async def epoch_detail(epoch: int): ranking_nodes: list = [] if ranking_completed: + commit_ranking = ranking_completed.payload.get("commit_ranking") or {} + contrib_ranking = ( + ranking_completed.payload.get("contributor_ranking") + or ranking_completed.payload.get("ranking") + or {} + ) + commit_rank_links = [ + ( + f"{cid[:20]} = {score}", + _evidence_path("commit", cid), + ) + for cid, score in sorted( + commit_ranking.items(), + key=lambda kv: Decimal(str(kv[1])), + reverse=True, + ) + ] ranking_nodes = [ ["p", ranking_completed.payload.get("summary") or "ranking completed"], _dl_rows([ @@ -2362,10 +2428,10 @@ async def epoch_detail(epoch: int): ranking_completed.event_id, )), ]), - ["pre.blob", json.dumps( - ranking_completed.payload.get("ranking") or {}, - indent=2, sort_keys=True, - )], + ["h3", "commit ranking"], + _link_list(commit_rank_links) if commit_rank_links else ["p.note", "(none)"], + ["h3", "contributor rollup"], + ["pre.blob", json.dumps(contrib_ranking, indent=2, sort_keys=True)], ] elif ranking_started: ranking_nodes = [["p.note", f"Ranking started: {ranking_started.event_id}"]] @@ -2386,14 +2452,9 @@ async def epoch_detail(epoch: int): else: emission_node = ["p.note", "No emission for this epoch."] - contributors = { - e.payload.get("contributor") - for e in commit_evs - if e.payload.get("contributor") - } no_comparisons_note = "No comparisons." - if len(contributors) <= 1: - no_comparisons_note += " Single-contributor — no LLM judgments." + if len(commit_evs) <= 1: + no_comparisons_note += " Fewer than two eligible commits — nothing to pairwise-rank." body = [ _evidence_nav(), @@ -2511,9 +2572,14 @@ async def comparison_detail(comparison_id: str): j.payload.get("summary") or jid, _evidence_path("judgment", jid), )) - commit_links = [] - for cid in (side_a.get("commit_ids") or []) + (side_b.get("commit_ids") or []): - commit_links.append((cid, _evidence_path("commit", cid))) + commit_ids = [] + for side in (side_a, side_b): + cid = side.get("commit_id") + if cid: + commit_ids.append(cid) + else: + commit_ids.extend(side.get("commit_ids") or []) + commit_links = [(cid, _evidence_path("commit", cid)) for cid in commit_ids] return _evidence_page(f"comparison {comparison_id[:24]}", [ _evidence_nav(_a(_evidence_path("epoch", str(ev.epoch)), f"epoch {ev.epoch}")), ["div.eyebrow", "comparison"], @@ -2522,8 +2588,8 @@ async def comparison_detail(comparison_id: str): ("summary", p.get("summary")), ("ranking_run_id", p.get("ranking_run_id")), ("evidence_event", _a(_evidence_path("event", ev.event_id), ev.event_id)), - ("side_a", side_a.get("contributor")), - ("side_b", side_b.get("contributor")), + ("side_a", f"{side_a.get('commit_id', '?')} ({side_a.get('contributor', '?')})"), + ("side_b", f"{side_b.get('commit_id', '?')} ({side_b.get('contributor', '?')})"), ]), ["p", _a(f"/comparisons/{comparison_id}/prompt", "download prompt")], ["h2", "commits"], @@ -2534,12 +2600,12 @@ async def comparison_detail(comparison_id: str): _link_list(judgment_links), ["h2", "prompt"], _pre_blob(_blob_text(p.get("prompt"))), - ["h2", f"side A — {side_a.get('contributor', '?')}"], + ["h2", f"side A — {side_a.get('commit_id', side_a.get('contributor', '?'))}"], ["h3", "message"], _pre_blob(_blob_text(side_a.get("message"))), ["h3", "diff"], _pre_blob(_blob_text(side_a.get("diff"))), - ["h2", f"side B — {side_b.get('contributor', '?')}"], + ["h2", f"side B — {side_b.get('commit_id', side_b.get('contributor', '?'))}"], ["h3", "message"], _pre_blob(_blob_text(side_b.get("message"))), ["h3", "diff"], @@ -3156,9 +3222,9 @@ async def watch(): ], ["p.note", ( - "Pairwise council voting is ready." + "Pairwise council ranks every eligible commit." if key_ok else - "Single-contributor epochs can finalize, but contested rankings require OPENROUTER_API_KEY." + "Epochs with two or more eligible commits require OPENROUTER_API_KEY." ) ], ], diff --git a/tests/integration.clj b/tests/integration.clj index 11140e95a8cd86768a661a30e6b29a3ddfc95fcc..39b2476cb5ddf80733769f61343c81ba7287a974 100644 --- a/tests/integration.clj +++ b/tests/integration.clj @@ -507,7 +507,7 @@ (bind or-state @(:state or-mock)) (assert! (pos? (:model-requests or-state)) "OpenRouter /models was called") - (assert! (>= (:compare-requests or-state) 3) "at least 3 pairwise LLM calls (2 authors × 3 models)") + (assert! (>= (:compare-requests or-state) 3) "at least 3 pairwise LLM calls (2 commits × 3 models)") (bind ledger2 (get-json base-url "/api/ledger")) (assert! (>= (count ledger2) 3) @@ -543,6 +543,8 @@ "epoch page links comparisons") (assert! (str/includes? epoch-html "/judgments/") "epoch page links judgments") + (assert! (str/includes? epoch-html "commit ranking") + "epoch page shows per-commit ranking") (bind commit-href (second (re-find #"/commits/(c_[a-f0-9]+)" epoch-html))) (assert! (some? commit-href) "found a commit id on epoch page") diff --git a/tests/test_git_discovery.py b/tests/test_git_discovery.py index 00d26bfa85737b178c8822804e278211974e0efe..0f002a58bd9a122d41c5a85e32c16ed2b4404d2f 100644 --- a/tests/test_git_discovery.py +++ b/tests/test_git_discovery.py @@ -434,7 +434,7 @@ def test_emission_distribution_sums_exactly_to_total( assert entry.discovery_snapshot_id == "ranked-snapshot" -def test_single_contributor_ranking_is_total_and_uses_no_pairwise_votes( +def test_single_commit_ranking_skips_pairwise( discovery_config, monkeypatch, ): monkeypatch.setattr(c, "store", c.JsonlStore(discovery_config / "ledger.jsonl")) @@ -454,6 +454,65 @@ def test_single_contributor_ranking_is_total_and_uses_no_pairwise_votes( assert info["ranking_event_id"] +def test_same_contributor_multiple_commits_runs_pairwise( + discovery_config, monkeypatch, +): + monkeypatch.setattr(c, "store", c.JsonlStore(discovery_config / "ledger.jsonl")) + calls = {"n": 0} + + async def models(n=3): + return ["m1", "m2", "m3"] + + async def compare(model_id, side_a, side_b, **kwargs): + calls["n"] += 1 + assert "commit_id" in side_a and "commit_id" in side_b + if kwargs.get("persist"): + attempt_id = c.attempt_id_for(kwargs["comparison_id"], model_id, 1) + await c.append_evidence(kwargs["epoch"], "llm.judgment", { + "judgment_id": c.judgment_id_for({ + "attempt_id": attempt_id, + "comparison_id": kwargs["comparison_id"], + "model_id": model_id, + "winner": "A", + "ratio": "2:1", + "explanation": "ok", + }), + "attempt_id": attempt_id, + "comparison_id": kwargs["comparison_id"], + "model_id": model_id, + "winner": "A", + "ratio": "2:1", + "explanation": "ok", + "summary": "ok", + }) + return {"winner": "A", "ratio": "2:1", "explanation": "ok"} + + monkeypatch.setattr(c, "fetch_top_models", models) + monkeypatch.setattr(c, "llm_pairwise_compare", compare) + monkeypatch.setattr(c, "OPENROUTER_API_KEY", "test-key") + commits = [ + { + "contributor": "alice", + "oid": "sha1:" + char * 40, + "message": f"msg-{char}", + "patch": f"patch-{char}", + } + for char in ("a", "b", "c") + ] + ranking, used, info = asyncio.run(c.rank_commits(commits, epoch=0)) + assert set(ranking) == {"alice"} + assert ranking["alice"] > 0 + assert used == ["m1", "m2", "m3"] + assert calls["n"] >= 3 + completed = next( + e for e in c.store.read() + if isinstance(e, c.Evidence) and e.kind == "ranking.completed" + ) + assert len(completed.payload["commit_ranking"]) == 3 + assert "alice" in completed.payload["contributor_ranking"] + assert info["ranking_event_id"] + + def test_any_council_failure_aborts_ranking(discovery_config, monkeypatch): monkeypatch.setattr(c, "store", c.JsonlStore(discovery_config / "ledger.jsonl")) @@ -479,16 +538,16 @@ def test_any_council_failure_aborts_ranking(discovery_config, monkeypatch): asyncio.run(c.rank_commits(commits, epoch=0)) -def test_contested_ranking_requires_openrouter_key(monkeypatch): +def test_multi_commit_ranking_requires_openrouter_key(monkeypatch): monkeypatch.setattr(c, "OPENROUTER_API_KEY", "") commits = [ { - "contributor": contributor, + "contributor": "alice", "oid": "sha1:" + char * 40, - "message": contributor, + "message": char, "patch": "patch", } - for contributor, char in [("alice", "a"), ("bob", "b")] + for char in ("a", "b") ] with pytest.raises(RuntimeError, match="OPENROUTER_API_KEY"): asyncio.run(c.rank_commits(commits)) Side B — contributor: tommy-mor Side B — commit message: [c94456ff] Make feed catch-up stable and permission-aware Anchor implicit feeds to durable ingest order and cover multi-user private-room visibility so concurrent posts are not missed or leaked. Co-authored-by: Cursor Side B — unified diff (full patch): diff --git a/cli/src/main.rs b/cli/src/main.rs index abb5a55b49f60fe28fbfd4ec02715cb94ea0b4ec..c4f1494df3aedbd8b883aea6249579aa8336abfe 100644 --- a/cli/src/main.rs +++ b/cli/src/main.rs @@ -878,6 +878,30 @@ mod tests { "graph: 4 items, 3/6 pairs (50.0% density), 1 component, connected" ); } + + #[test] + fn feed_without_since_uses_logged_in_delegate_from_env() { + let key = "SLUG_DELEGATE"; + let previous = std::env::var_os(key); + let expected = "00000000-0000-0000-0000-0000000000ee:test:local/model"; + std::env::set_var(key, expected); + + let cli = Cli::try_parse_from(["slugsocial", "feed"]).expect("parse feed"); + + match previous { + Some(value) => std::env::set_var(key, value), + None => std::env::remove_var(key), + } + match cli.cmd { + Some(Command::Feed { + delegate, since, .. + }) => { + assert_eq!(delegate.as_deref(), Some(expected)); + assert!(since.is_none()); + } + _ => panic!("expected feed command"), + } + } } async fn run_scoped(base: &str, room: &str, sub: ScopedCmd) -> Result<()> { @@ -1626,7 +1650,15 @@ async fn run() -> Result<()> { } else { for p in &resp.posts { let ago = slug_types::timeago::timeago(now_ms, p.ts); - println!("", p.id, ago); + let thread_attr = p + .thread + .as_deref() + .map(|thread| format!(" thread=\"{thread}\"")) + .unwrap_or_default(); + println!( + "", + p.id, ago, p.room, thread_attr + ); print!("{}", p.body); if !p.body.ends_with('\n') { println!(); } println!(""); diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs index afc4f95bef160c1e38ecff2c096d6440cd94e2b3..46d748f918d9b225acc4ecedfe5a1793089407b5 100644 --- a/server/src/api/rpc.rs +++ b/server/src/api/rpc.rs @@ -72,6 +72,80 @@ fn can_view_scope(reduced: &ReducerState, scope: &ScopeId, principal: Option<&st } } +/// Build a feed in durable ingest order. +/// +/// An implicit feed boundary is an ingest position, not only its millisecond timestamp. Two users +/// can post in the same millisecond, and wall-clock timestamps can move backwards during replay. +/// Explicit `since` remains a timestamp query for API compatibility, but scans the whole ordered +/// ledger rather than assuming timestamps are monotonic. +fn rpc_feed( + reduced: &ReducerState, + viewer: &str, + delegate: Option, + requested_since: Option, + implicit_anchor: Option<(usize, i64)>, + limit: usize, +) -> FeedResponse { + let since = requested_since.or_else(|| implicit_anchor.map(|(_, ts)| ts)); + let implicit_anchor_index = requested_since + .is_none() + .then(|| implicit_anchor.map(|(index, _)| index)) + .flatten(); + + let matching: Vec<&str> = reduced + .ingests_ordered + .iter() + .enumerate() + .rev() + .filter(|(index, id)| { + reduced.ingests_by_id.get(id.as_str()).is_some_and(|ing| { + match requested_since { + Some(cutoff) => ing.ts > cutoff, + None => implicit_anchor_index.is_none_or(|anchor| *index > anchor), + } + }) + }) + .map(|(_, id)| id.as_str()) + .filter(|id| { + reduced.ingests_by_id.get(*id).is_some_and(|ing| { + let scope = scope_from_room_wire(&ing.room_id); + can_view_scope(reduced, &scope, Some(viewer)) + }) + }) + .filter(|id| !reduced.redacted_posts.contains(*id)) + .collect(); + + let total = matching.len(); + let posts = matching + .into_iter() + .take(limit) + .filter_map(|id| reduced.ingests_by_id.get(id)) + .map(|ing| { + let scope = scope_from_room_wire(&ing.room_id); + let thread_post_index = reduced.try_thread_post_index_chronological( + &scope, + &ing.thread_tag, + &ing.id, + ); + FeedPost { + ts: ing.ts, + id: ing.id.clone(), + room: ing.room_id.clone(), + thread: Some(ing.thread_tag.clone()), + thread_post_index, + body: ing.raw.clone(), + } + }) + .collect(); + + FeedResponse { + delegate, + since, + posts, + total, + } +} + fn principal_from_optional_bearer(headers: &HeaderMap, reduced: &ReducerState) -> Result, RpcErr> { if headers.contains_key(axum::http::header::AUTHORIZATION) { verify_bearer_principal(headers, reduced) @@ -1506,60 +1580,27 @@ pub async fn handle_rpc_batch( Some("this delegate is not bound to your signed-in account".into()), ) } else { - let since_default = reduced + let implicit_anchor = reduced .ingests_ordered .iter() + .enumerate() .rev() - .filter_map(|id| reduced.ingests_by_id.get(id)) - .find(|ing| { - if ing.delegate.as_deref() != Some(delegate_stored.as_str()) { - return false; - } - let scope = scope_from_room_wire(&ing.room_id); - can_view_scope(&reduced, &scope, Some(viewer.as_str())) - }) - .map(|ing| ing.ts); - let since = since.or(since_default); - let cutoff = since.unwrap_or(0); - let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT); - let matching: Vec<&str> = reduced.ingests_ordered.iter().rev() - .map(|id| id.as_str()) - .take_while(|id| reduced.ingests_by_id.get(*id).is_some_and(|ing| ing.ts > cutoff)) - .filter(|id| { - reduced.ingests_by_id.get(*id).is_some_and(|ing| { - let scope = scope_from_room_wire(&ing.room_id); - can_view_scope(&reduced, &scope, Some(viewer.as_str())) + .find_map(|(index, id)| { + reduced.ingests_by_id.get(id).and_then(|ing| { + (ing.delegate.as_deref() + == Some(delegate_stored.as_str())) + .then_some((index, ing.ts)) }) - }) - .filter(|id| !reduced.redacted_posts.contains(*id)) - .collect(); - let total = matching.len(); - let posts: Vec = matching.into_iter() - .take(limit) - .filter_map(|id| reduced.ingests_by_id.get(id)) - .map(|ing| { - let scope = scope_from_room_wire(&ing.room_id); - let thread_post_index = reduced - .try_thread_post_index_chronological( - &scope, - &ing.thread_tag, - &ing.id, - ); - FeedPost { - ts: ing.ts, - id: ing.id.clone(), - thread: Some(ing.thread_tag.clone()), - thread_post_index, - body: ing.raw.clone(), - } - }) - .collect(); - line_ok(RpcResult::Feed(FeedResponse { - delegate: Some(delegate_stored), + }); + let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT); + line_ok(RpcResult::Feed(rpc_feed( + &reduced, + &viewer, + Some(delegate_stored), since, - posts, - total, - })) + implicit_anchor, + limit, + ))) }; drop(reduced); line @@ -1567,60 +1608,25 @@ pub async fn handle_rpc_batch( None => { // Session catch-up: last time *you* posted anything (delegate or not), so revisiting // an old chat with only a token still gets a sane cutoff. - let since_default = reduced + let implicit_anchor = reduced .ingests_ordered .iter() + .enumerate() .rev() - .filter_map(|id| reduced.ingests_by_id.get(id)) - .find(|ing| { - if ing.principal != viewer { - return false; - } - let scope = scope_from_room_wire(&ing.room_id); - can_view_scope(&reduced, &scope, Some(viewer.as_str())) - }) - .map(|ing| ing.ts); - let since = since.or(since_default); - let cutoff = since.unwrap_or(0); - let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT); - let matching: Vec<&str> = reduced.ingests_ordered.iter().rev() - .map(|id| id.as_str()) - .take_while(|id| reduced.ingests_by_id.get(*id).is_some_and(|ing| ing.ts > cutoff)) - .filter(|id| { - reduced.ingests_by_id.get(*id).is_some_and(|ing| { - let scope = scope_from_room_wire(&ing.room_id); - can_view_scope(&reduced, &scope, Some(viewer.as_str())) + .find_map(|(index, id)| { + reduced.ingests_by_id.get(id).and_then(|ing| { + (ing.principal == viewer).then_some((index, ing.ts)) }) - }) - .filter(|id| !reduced.redacted_posts.contains(*id)) - .collect(); - let total = matching.len(); - let posts: Vec = matching.into_iter() - .take(limit) - .filter_map(|id| reduced.ingests_by_id.get(id)) - .map(|ing| { - let scope = scope_from_room_wire(&ing.room_id); - let thread_post_index = reduced - .try_thread_post_index_chronological( - &scope, - &ing.thread_tag, - &ing.id, - ); - FeedPost { - ts: ing.ts, - id: ing.id.clone(), - thread: Some(ing.thread_tag.clone()), - thread_post_index, - body: ing.raw.clone(), - } - }) - .collect(); - let line = line_ok(RpcResult::Feed(FeedResponse { - delegate: None, + }); + let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT); + let line = line_ok(RpcResult::Feed(rpc_feed( + &reduced, + &viewer, + None, since, - posts, - total, - })); + implicit_anchor, + limit, + ))); drop(reduced); line } diff --git a/server/tests/integration_rooms.rs b/server/tests/integration_rooms.rs index a3b378267e090a016a7e663f103a0dd9f482690b..e623523ba352ce456674a399542c689505760b78 100644 --- a/server/tests/integration_rooms.rs +++ b/server/tests/integration_rooms.rs @@ -1,6 +1,9 @@ mod support; use slug_types::room_route_segment; +use slugsocial_server::events::{ + AgentBound, Event, GrantAdded, GrantRevoked, Ingest, RoomCreated, ThreadCapability, +}; use support::*; #[tokio::test] @@ -473,6 +476,247 @@ async fn test_feed_without_delegate_uses_principal_last_post_including_delegate( ); } +#[tokio::test] +async fn test_feed_uses_delegate_ingest_position_when_multi_user_timestamps_collide() { + let (addr, _tmp, _log, state, _handle) = create_test_server_with_state().await; + seed_test_identity(&state, "bob", "bobtok", "bobsecret").await; + let client = reqwest::Client::new(); + let alice_delegate = + "00000000-0000-0000-0000-0000000000c1:feedtest:local/alice-model"; + let bob_delegate = + "00000000-0000-0000-0000-0000000000c2:feedtest:local/bob-model"; + + { + let mut reduced = state.reduced.write().await; + for (agent, username) in [ + (alice_delegate, "testuser"), + (bob_delegate, "bob"), + ] { + reduced.apply_event(Event::AgentBound(AgentBound { + ts: 1, + agent: agent.to_string(), + username: username.to_string(), + })); + } + reduced.apply_event(Event::Ingest(Ingest { + ts: 100, + id: "alice-anchor".into(), + raw: "alice anchor".into(), + principal: "testuser".into(), + delegate: Some(alice_delegate.into()), + room_id: "public".into(), + thread_tag: "feed-order".into(), + })); + reduced.apply_event(Event::Ingest(Ingest { + ts: 100, + id: "bob-same-millisecond".into(), + raw: "bob same-millisecond change".into(), + principal: "bob".into(), + delegate: Some(bob_delegate.into()), + room_id: "public".into(), + thread_tag: "feed-order".into(), + })); + // Event-log order remains authoritative even if the wall clock moves backwards. + reduced.apply_event(Event::Ingest(Ingest { + ts: 99, + id: "bob-clock-rollback".into(), + raw: "bob change after clock rollback".into(), + principal: "bob".into(), + delegate: Some(bob_delegate.into()), + room_id: "public".into(), + thread_tag: "feed-order".into(), + })); + } + + let feed = rpc_batch( + &client, + addr, + Some(&test_bearer()), + serde_json::json!([{ + "GetFeed": { "delegate": alice_delegate, "limit": 20 } + }]), + ) + .await; + let posts = feed["results"][0]["result"]["Feed"]["posts"] + .as_array() + .unwrap(); + let ids: Vec<&str> = posts.iter().filter_map(|p| p["id"].as_str()).collect(); + assert_eq!( + ids, + ["bob-clock-rollback", "bob-same-millisecond"], + "implicit feed cutoff must use append position, not timestamp" + ); +} + +#[tokio::test] +async fn test_feed_multi_user_private_room_visibility_and_revoked_anchor_access() { + let (addr, _tmp, _log, state, _handle) = create_test_server_with_state().await; + seed_test_identity(&state, "bob", "bobtok", "bobsecret").await; + seed_test_identity(&state, "carol", "caroltok", "carolsecret").await; + let client = reqwest::Client::new(); + let alice_delegate = + "00000000-0000-0000-0000-0000000000d1:feedtest:local/alice-model"; + let bob_delegate = + "00000000-0000-0000-0000-0000000000d2:feedtest:local/bob-model"; + let room_alice = "alice01/alice-room"; + let room_bob = "bob0001/bob-room"; + + { + let mut reduced = state.reduced.write().await; + for (agent, username) in [ + (alice_delegate, "testuser"), + (bob_delegate, "bob"), + ] { + reduced.apply_event(Event::AgentBound(AgentBound { + ts: 1, + agent: agent.to_string(), + username: username.to_string(), + })); + } + for (room_id, slug, owner) in [ + (room_alice, "alice-room", "testuser"), + (room_bob, "bob-room", "bob"), + ] { + reduced.apply_event(Event::RoomCreated(RoomCreated { + ts: 2, + room_id: room_id.to_string(), + slug: slug.to_string(), + owner: owner.to_string(), + })); + reduced.apply_event(Event::GrantAdded(GrantAdded { + ts: 2, + room_id: room_id.to_string(), + username: owner.to_string(), + capabilities: vec![ThreadCapability::View], + granted_by: owner.to_string(), + })); + } + + let mut add_ingest = + |ts, id: &str, raw: &str, principal: &str, delegate: Option<&str>, room: &str| { + reduced.apply_event(Event::Ingest(Ingest { + ts, + id: id.into(), + raw: raw.into(), + principal: principal.into(), + delegate: delegate.map(str::to_string), + room_id: room.into(), + thread_tag: "feed-permissions".into(), + })); + }; + add_ingest(10, "prehistory", "must remain before alice anchor", "carol", None, "public"); + add_ingest( + 11, + "alice-private-anchor", + "alice last posted here", + "testuser", + Some(alice_delegate), + room_alice, + ); + add_ingest( + 12, + "bob-public-anchor", + "bob last posted here", + "bob", + Some(bob_delegate), + "public", + ); + add_ingest(13, "alice-room-change", "visible only to alice", "carol", None, room_alice); + add_ingest(14, "bob-room-change", "visible only to bob", "carol", None, room_bob); + add_ingest(15, "public-change", "visible to everyone", "carol", None, "public"); + + reduced.apply_event(Event::GrantRevoked(GrantRevoked { + ts: 16, + room_id: room_alice.into(), + username: "testuser".into(), + capabilities: vec![ThreadCapability::View], + revoked_by: "testuser".into(), + })); + } + + let alice_feed = rpc_batch( + &client, + addr, + Some(&test_bearer()), + serde_json::json!([{ + "GetFeed": { "delegate": alice_delegate, "limit": 20 } + }]), + ) + .await; + let alice_posts = alice_feed["results"][0]["result"]["Feed"]["posts"] + .as_array() + .unwrap(); + let alice_ids: Vec<&str> = alice_posts + .iter() + .filter_map(|p| p["id"].as_str()) + .collect(); + assert_eq!( + alice_ids, + ["public-change", "bob-public-anchor"], + "revoked private content must be hidden without moving the delegate anchor backwards" + ); + assert!(!alice_ids.contains(&"prehistory")); + assert!( + alice_posts + .iter() + .all(|post| post["room"].as_str() == Some("public")), + "private posts must not leak and every feed post must identify its room" + ); + + let bob_bearer = test_bearer_for("bobtok", "bobsecret"); + let bob_feed = rpc_batch( + &client, + addr, + Some(&bob_bearer), + serde_json::json!([{ + "GetFeed": { "delegate": bob_delegate, "limit": 20 } + }]), + ) + .await; + let bob_ids: Vec<&str> = bob_feed["results"][0]["result"]["Feed"]["posts"] + .as_array() + .unwrap() + .iter() + .filter_map(|p| p["id"].as_str()) + .collect(); + assert_eq!(bob_ids, ["public-change", "bob-room-change"]); + assert_eq!( + bob_feed["results"][0]["result"]["Feed"]["posts"][1]["room"], + room_bob + ); + + // Restoring View exposes only changes after the same stable delegate anchor. + { + let mut reduced = state.reduced.write().await; + reduced.apply_event(Event::GrantAdded(GrantAdded { + ts: 17, + room_id: room_alice.into(), + username: "testuser".into(), + capabilities: vec![ThreadCapability::View], + granted_by: "testuser".into(), + })); + } + let restored = rpc_batch( + &client, + addr, + Some(&test_bearer()), + serde_json::json!([{ + "GetFeed": { "delegate": alice_delegate, "limit": 20 } + }]), + ) + .await; + let restored_ids: Vec<&str> = restored["results"][0]["result"]["Feed"]["posts"] + .as_array() + .unwrap() + .iter() + .filter_map(|p| p["id"].as_str()) + .collect(); + assert_eq!( + restored_ids, + ["public-change", "alice-room-change", "bob-public-anchor"] + ); +} + #[tokio::test] async fn test_private_room_thread_urls_use_t_segment() { let (addr, _tmp, _log, _handle) = create_test_server().await; diff --git a/server/tests/support/mod.rs b/server/tests/support/mod.rs index 4a620eaa875e7a1145f2a4e82cc4ff2be21d5345..a4320e991763617c1a760efad4b621977e2b74d0 100644 --- a/server/tests/support/mod.rs +++ b/server/tests/support/mod.rs @@ -20,8 +20,10 @@ pub fn sha256_hex(s: &str) -> String { /// Fixed bearer for integration tests (`TokenIssued` seeded into reducer in `create_test_server`). pub fn test_bearer() -> String { - let token_id = "testtok"; - let secret = "secret"; + test_bearer_for("testtok", "secret") +} + +pub fn test_bearer_for(token_id: &str, secret: &str) -> String { format!("slug_{token_id}_{secret}") } @@ -71,19 +73,27 @@ pub async fn rpc_batch( } pub async fn seed_test_token(state: &AppState) { + seed_test_identity(state, "testuser", "testtok", "secret").await; +} + +/// Add a distinct principal and bearer to a running integration-test server. +pub async fn seed_test_identity( + state: &AppState, + username: &str, + token_id: &str, + secret: &str, +) { let registered = Event::UserRegistered(UserRegistered { ts: 0, - username: "testuser".to_string(), + username: username.to_string(), provider: "test".to_string(), - provider_id: "testuser".to_string(), + provider_id: username.to_string(), }); - let token_id = "testtok"; - let secret = "secret"; let salt = "salt"; let token_hash = sha256_hex(&format!("{salt}:{secret}")); let ev = Event::TokenIssued(TokenIssued { ts: 0, - username: "testuser".to_string(), + username: username.to_string(), token_id: token_id.to_string(), token_hash, salt: salt.to_string(), diff --git a/types/src/lib.rs b/types/src/lib.rs index 211493935d19582607f5c87fb492faf47bdc6f53..cd6f94c60a4e1c3bfbce13bc0404b803f5f57c6d 100644 --- a/types/src/lib.rs +++ b/types/src/lib.rs @@ -264,6 +264,9 @@ pub struct FeedResponse { pub struct FeedPost { pub ts: i64, pub id: String, + /// Permission scope containing the post: `"public"` or a private room id. + #[serde(default)] + pub room: String, /// Primary thread tag (without #), if the ingest declared one. #[serde(skip_serializing_if = "Option::is_none")] pub thread: Option,