Side B changes the core ranking algorithm from author-level to per-commit pairwise ranking, fixing a real correctness gap (same-contributor multiple commits were never compared) and adds rollup logic, updated evidence schema, epoch page rendering, and new/updated tests covering the behavior. Side A is a sizable but purely additive UI feature (theme cookie/selector) plus a room-URL helper refactor, useful but narrower in scope and lower architectural impact than B's fix to the ranking/reward mechanism.
constitution · epochs · watch · epoch 3
comparison
c_3f420a1f5aa1 (tommy-mor) vs c_fbeec5c4ad18 (tommy-mor)
download prompt · raw event · cmp_4f26ef36ea72d3
council reasoning
B fixes ranking to pairwise-compare every eligible commit (not bundled per author) and only short-circuit on a single commit, with rollup scores, evidence fields, epoch UI, and tests—a lasting fairness design for emissions. A’s theme cookie/POST work is real UX polish plus useful private-room wire URL helpers, but much of the diff is repetitive layout/jar plumbing rather than core design.
Side B changes the core ranking algorithm from contributor-level comparisons to pairwise ranking of individual commits, removes the incorrect single-contributor short circuit, rolls commit scores back up to contributors, updates evidence/UI, and adds tests covering same-contributor multi-commit behavior. Side A mainly implements persistent theme handling across pages and login plus room-aware URL generation, which is useful, but it is largely feature integration rather than a fundamental correctness improvement to the project's ownership allocation logic.
sides
A — c_3f420a1f5aa1 (tommy-mor)
message
[2fe70b0e] themes
diff preview
diff --git a/server/src/api/auth.rs b/server/src/api/auth.rs
index 559db65de14c6157690ffbf18eca0cf65b0a5202..b3631b06153d52f88348fef927e7a024b7b85ad6 100644
--- a/server/src/api/auth.rs
+++ b/server/src/api/auth.rs
@@ -1,7 +1,7 @@
use axum::{
body::Body,
extract::{Path, Query, State},
- http::{header, HeaderMap, HeaderValue, StatusCode},
+ http::{header, HeaderMap, HeaderValue, StatusCode, Uri},
response::{IntoResponse, Redirect, Response},
Form, Json,
};
@@ -17,7 +17,7 @@ use crate::{
events::{Event, GrantAdded, TokenIssued, UserRegistered},
html::{
auth_complete_page, auth_signed_in_fragment, choose_username_error_fragment,
- choose_username_page, JsBuilder,
+ choose_username_page, theme_cookie_header_from_jar, theme_from_jar, theme_next_from_uri, JsBuilder,
},
identity::{parse_agent, parse_username},
reducer::ReducerState,
@@ -48,15 +48,17 @@ fn js_form_error_fragment(session: &str, error: &str) -> Response {
.into_response()
}
-fn js_signed_in_fragment(bearer: &str) -> Response {
+fn js_signed_in_fragment(bearer: &str, jar: &CookieJar) -> Response {
let mut response = JsBuilder::new()
.id("choose-username-form")
.morph_inner(auth_signed_in_fragment())
.redirect("/auth/complete")
.into_response();
- response
- .headers_mut()
- .insert(header::SET_COOKIE, session_cookie_header_value(bearer));
+ let headers = response.headers_mut();
+ headers.append(header::SET_COOKIE, session_cookie_header_value(bearer));
+ if let Some(theme) = theme_cookie_header_from_jar(jar) {
+ headers.append(header::SET_COOKIE, theme);
+ }
response
}
@@ -69,13 +71,18 @@ pub fn optional_principal(headers: &HeaderMap, jar: &CookieJar, reduced: &Reduce
verify_token(reduced, c.value()).ok()
}
-fn redirect_with_session_cookie(public_url: &str, path_and_query: &str, bearer: &str) -> Response {
- Response::builder()
+fn redirect_with_session_cookie(public_url: &str, path_and_query: &str, bearer: &str, jar: &CookieJar) -> Response {
+ let mut res = Response::builder()
.status(StatusCode::TEMPORARY_REDIRECT)
.header(header::LOCATION, format!("{public_url}{path_and_query}"))
- .header(header::SET_COOKIE, session_cookie_header_value(bearer))
.body(Body::empty())
- .unwrap()
+ .unwrap();
+ let headers = res.headers_mut();
+ headers.append(header::SET_COOKIE, session_cookie_header_value(bearer));
+ if let Some(theme) = theme_cookie_header_from_jar(jar) {
+ headers.append(header::SET_COOKIE, theme);
+ }
+ res
}
async fn apply_invite_redemption(state: &AppState, invite_token: &str, grantee_username: &str) -> Result<(), String> {
@@ -286,7 +293,11 @@ pub struct AuthCallbackQuery {
pub state: String,
}
-pub async fn get_auth_callback(Query(q): Query<AuthCallbackQuery>, State(state): State<AppState>) -> impl IntoResponse {
+pub async fn get_auth_callback(
+ Query(q): Query<AuthCallbackQuery>,
+ State(state): State<AppState>,
+ jar: CookieJar,
+) -> impl IntoResponse {
let sessions = pending_sessions(&state);
{
let sessions_read = sessions.read().await;
@@ -365,7 +376,7 @@ pub async fn get_auth_callback(Query(q): Query<AuthCallbackQuery>, State(state):
}
let cookie_bearer = bearer.clone();
s.complete = Some((username, bearer));
- return redirect_with_session_cookie(&public_url, "/", &cookie_bearer).into_response();
+ return redirect_with_session_cookie(&public_url, "/", &cookie_bearer, &jar).into_response();
}
}
@@ -378,14 +389,20 @@ pub struct ChooseUsernameQuery {
pub error: Option<String>,
}
-pub async fn get_choose_username(Query(q): Query<ChooseUsernameQuery>, State(state): State<AppState>) -> impl IntoResponse {
+pub async fn get_choose_username(
+ Query(q): Query<ChooseUsernameQuery>,
+ State(state): State<AppState>,
+ jar: CookieJar,
+ uri: Uri,
+) -> impl IntoResponse {
let sessions = pending_sessions(&state);
let sessions_read = sessions.read().await;
if !sessions_read.contains_key(&q.session) {
return api_error(StatusCode::NOT_FOUND, "unknown session", None).into_response();
}
drop(sessions_read);
- choose_username_page(&q.session, q.error.as_deref()).into_response()
+ let next = theme_next_from_uri(&uri);
+ choose_username_page(&q.session, q.error.as_deref(), theme_from_jar(&jar), &next).into_response()
}
#[derive(Debug, Deserialize)]
@@ -396,6 +413,7 @@ pub struct ChooseUsernameForm {
pub async fn post_choose_username(
State(state): State<AppState>,
+ jar: CookieJar,
Form(form): Form<ChooseUsernameForm>,
) -> impl IntoResponse {
let canon_user = match parse_username(&form.username) {
@@ -477,7 +495,7 @@ pub async fn post_choose_username(
s.complete = Some((canon_user.clone(), bearer.clone()));
}
- js_signed_in_fragment(&bearer).into_response()
+ js_signed_in_fragment(&bearer, &jar).into_response()
}
/// Start a browser-only OAuth flow (no CLI polling). Sets session cookie on success.
@@ -569,8 +587,9 @@ pub async fn get_pending_session(
.into_response()
}
-pub async fn get_auth_complete() -> impl IntoResponse {
- auth_complete_page()
+pub async fn get_auth_complete(jar: CookieJar, uri: Uri) -> impl IntoResponse {
+ let next = theme_next_from_uri(&uri);
+ auth_complete_page(theme_from_jar(&jar), &next).into_response()
}
pub async fn get_whoami(State(state): State<AppState>, headers: HeaderMap) -> impl IntoResponse {
diff --git a/server/src/api/helpers.rs b/server/src/api/helpers.rs
index 81e2a55fa3abb8609b4099f91a989480336e11eb..9b71491e9f9efc44a2a4beba09be8f64bd2ff2ee 100644
--- a/server/src/api/helpers.rs
+++ b/server/src/api/helpers.rs
@@ -39,6 +39,55 @@ pub fn item_path_for_api(item: &str) -> String {
}
}
+/// Same as [`item_path_for_api`], but for private rooms ontology items are prefixed with
+/// `/r/{short}/{slug}` so the URL matches the web app (`/r/…/~/…` routes).
+pub fn item_path_for_api_in_room(item: &str, room_wire: &str) -> String {
+ let room = room_wire.trim();
+ if room.is_empty() || room == "public" {
+ return item_path_for_api(item);
+ }
+ let Some((short, slug)) = room.split_once('/') else {
+ return item_path_for_api(item);
+ };
+ if short.is_empty() || slug.is_empty() {
+ return item_path_for_api(item);
+ }
+ let Some(c) = CanonicalItemUrl::parse(item) else {
+ return item_path_for_api(item);
+ };
+ let root = CanonicalItemUrl::ontology_root();
+ let item_norm = c.as_str().trim_end_matches('/');
+ let root_norm = root.as_str().trim_end_matches('/');
+ if let Some(tail) = c.tilde_tail() {
+ return if tail.is_empty() {
+ format!("https://slug.social/r/{short}/{slug}/~")
+ } else {
+ format!("https://slug.social/r/{short}/{slug}/~/{}", tail)
+ };
+ }
+ if item_norm == root_norm {
+ return format!("https://slug.social/r/{short}/{slug}/~");
+ }
+ item_path_for_api(item)
+}
+
+/// Absolute thread URL for forum JSON (`/t/…` vs `/r/…/t/…`).
+pub fn forum_thread_web_url(room_wire: &str, thread_tag: &str) -> String {
+ let room = room_wire.trim();
+ let tag = thread_tag.trim().trim_start_matches('#');
+ if room.is_empty() || room == "public" {
+ format!("https://slug.social/t/{tag}")
+ } else if let Some((short, slug)) = room.split_once('/') {
+ if short.is_empty() || slug.is_empty() {
+ format!("https://slug.social/t/{tag}")
+ } else {
+ format!("https://slug.social/r/{short}/{slug}/t/{tag}")
+ }
+ } else {
+ format!("https://slug.social/t/{tag}")
+ }
+}
+
/// Resolve an item path as a first-class canonical path.
pub fn resolve_item(item: &str) -> Result<String, String> {
let canonical = canonicalize_item(item);
@@ -188,3 +237,52 @@ pub fn vote_touches_path(a: &str, b: &str, parent_canon: &str) -> bool {
let under = |item: &str| item == parent_canon || item.starts_with(&format!("{}/", parent_canon));
under(a) || under(b)
}
+
+#[cfg(test)]
+mod wire_url_tests {
+ use super::{forum_thread_web_url, item_path_for_api_in_room};
+
+ #[test]
+ fn public_room_unchanged() {
+ let u = "https://slug.social/~/a/b";
+ assert_eq!(item_path_for_api_in_room(u, "public"), u);
+ }
+
+ #[test]
+ fn private_room_prefixes_ontology() {
+ assert_eq!(
+ item_path_for_api_in_room("https://slug.social/~/topic/x", "9ab12cd/my-room"),
+ "https://slug.social/r/9ab12cd/my-room/~/topic/x"
+ );
+ }
+
+ #[test]
+ fn private_room_ontology_root() {
+ assert_eq!(
+ item_path_for_api_in_room("https://slug.social/~", "9ab12cd/my-room"),
+ "https://slug.social/r/9ab12cd/my-room/~"
+ );
+ assert_eq!(
+ item_path_for_api_in_room("https://slug.social/~/", "9ab12cd/my-room"),
+ "https://slug.social/r/9ab12cd/my-room/~"
+ );
+ }
+
+ #[test]
+ fn external_url_untouched_in_private_room() {
+ let u = "https://example.com/z";
+ assert_eq!(item_path_for_api_in_room(u, "9ab12cd/my-room"), u);
+ }
+
+ #[test]
+ fn forum_web_public_vs_room() {
+ assert_eq!(
+ forum_thread_web_url("public", "debate"),
+ "https://slug.social/t/debate"
+ );
+ assert_eq!(
+ forum_thread_web_url("9ab12cd/my-room", "#debate"),
+ "https://slug.social/r/9ab12cd/my-room/t/debate"
+ );
+ }
+}
diff --git a/server/src/api/rpc.rs b/server/src/api/rpc.rs
index 31f5fcfb4eaf4df0a9cbac532dd3dedfe3611810..5b91f5836625eedbb1cd9423168046e3fb576c17 100644
--- a/server/src/api/rpc.rs
+++ b/server/src/api/rpc.rs
@@ -27,8 +27,9 @@ use crate::{
use super::auth::verify_bearer_principal;
use super::helpers::{
- compute_connectivity_stats, is_pair_voted, item_path_for_api, now_ms, paginate_rankings,
- parse_parent_specs, pick_random_distinct, resolve_item, vote_touches_path,
+ compute_connectivity_stats, forum_thread_web_url, is_pair_voted, item_path_for_api,
+ item_path_for_api_in_room, now_ms, paginate_rankings, parse_parent_specs, pick_random_distinct,
+ resolve_item, vote_touches_path,
};
use super::validate::{normalize_room_and_thread, validate_ingest_document};
@@ -148,6 +149,7 @@ fn compute_scope_rank_changes(
parent: &str,
before: &crate::scope_rank::ChildrenRankings,
after: &crate::scope_rank::ChildrenRankings,
+ room_wire: &str,
) -> Option<ScopeRankChanges> {
fn build_positions(rankings: &crate::scope_rank::ChildrenRankings) -> HashMap<String, Option<RankPosition>> {
let mut map = HashMap::new();
@@ -182,7 +184,7 @@ fn compute_scope_rank_changes(
};
if changed {
changes.push(RankChange {
- item: item_path_for_api(&item),
+ item: item_path_for_api_in_room(&item, room_wire),
before: b,
after: a,
});
@@ -204,7 +206,7 @@ fn compute_scope_rank_changes(
parent: if parent.is_empty() {
"/".to_string()
} else {
- item_path_for_api(parent)
+ item_path_for_api_in_room(parent, room_wire)
},
changes,
})
@@ -256,6 +258,7 @@ fn build_rank_response_for_content(
offset: usize,
limit: Option<usize>,
want_percent: bool,
+ room_wire: &str,
) -> Result<RankResponse, RpcErr> {
let parent_owned = parent.map(|s| s.to_string());
let specs = parse_parent_specs(parent_owned.as_ref());
@@ -299,7 +302,7 @@ fn build_rank_response_for_content(
.ranked
.into_iter()
.map(|r| RankRow {
-
… preview truncated; 42,928 characters omittedB — c_fbeec5c4ad18 (tommy-mor)
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 <cursoragent@cursor.com>
diff preview
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))}
… preview truncated; 12,453 characters omittedHardlinks — judgments / attempts / prompt
judgments
attempts
Prompt text is loaded only by the download route.