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: [8f6be6d0] Add copy button for garden rankings (markdown clipboard) (#168) * Add garden ranking markdown copy button via POST /ui Introduce HtmlUiAction::CopyGardenRank that rebuilds the visible child ranking and returns JsBuilder clipboard JS (fetch → eval), matching CopyThread. Place a copy control on garden ranking headings; clipboard text is a concise markdown numbered list with unranked bullets. Co-authored-by: tommy * Fix paren balance in garden ranking copy browser test Co-authored-by: tommy --------- Co-authored-by: Cursor Agent Side A — unified diff (full patch): diff --git a/agents.md b/agents.md index 7d6fea5791f7c95677e17e8975a14df83f998fd6..1dc989e4b23071f2eef69f2479c9a1ca2bd04b32 100644 --- a/agents.md +++ b/agents.md @@ -40,6 +40,8 @@ Strict **CSP** that blocks `eval` would break the current app. Other projects ma - **Non-morph `POST /ui` responses:** **`SetGardenPin`** returns **`303 See Other`** and **`Set-Cookie`** (same as **`POST /theme`**). Garden pin/unpin is a normal **`

`** — browser navigation applies cookies reliably (see **`test/browser_garden_pin.clj`**). Each **`__rpc__`** payload includes **`form_action: "/ui"`**; **`post_ui_html`** rejects mismatches to bind tokens to the UI endpoint. +- **`CopyGardenRank`:** Browser copy control on garden ranking headings. Returns **`text/javascript`** via **`JsBuilder::clipboard_write_text_and_label_btn`** (same **`fetch` → `eval`** loop as **`CopyThread`**). Payload includes **`room`**, **`parent_path`**, **`depth`**, **`copy_btn_id`**, and optional **`external_hosts`** (for **`/-/`** host-root indexes). Clipboard text is a concise markdown numbered list of display paths (plus unranked bullets). + - **`VoteComparePost`:** On success returns **`text/javascript`** that **morphs** **`#vote-edge-history-region`** (recomputed **`

`** (class **`vote-compare-login-cta`**); after OAuth / username selection they return to that matchup. An unauthenticated **`VoteComparePost`** (forged/stale form) still JS-redirects to the same **`/login?next=`** target. - **`ThreadGraduate` / `GraduateThread`:** Private-room forum threads with **Manage** can be published to the public site under the same tag. The writer replays non-redacted ingests into **`room: public`** (chronological order), then appends a durable **`ThreadGraduated`** marker. Graduated private threads show a banner linking to public **`/t/:tag`**, block further private posts, and cannot be graduated twice. CLI: **`npx slugsocial private forum graduate `**; RPC: **`ThreadGraduate`**. diff --git a/server/src/api/ui_html.rs b/server/src/api/ui_html.rs index b4a0c9e87e462050bd52728e49e0d6781bf1cfc8..611956d0a46062b49ce350be176e4be139312ff0 100644 --- a/server/src/api/ui_html.rs +++ b/server/src/api/ui_html.rs @@ -24,9 +24,9 @@ use crate::{ external_resolver_status_markup, fragment_new_thread_slot, login_to_post_hint_markup, parse_html_ui_from_form, room_members_section_markup, thread_feed_html, thread_feed_html_for_room, thread_feed_region_markup, thread_ui_collapse_redacted_post, - thread_ui_copy_thread, - thread_ui_expand_post_full, thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room, - user_can_view_room, HtmlUiAction, JsBuilder, ThreadNav, + garden_ui_copy_rank, thread_ui_copy_thread, thread_ui_expand_post_full, + thread_ui_expand_redacted_post, ui_js_warn, user_can_post_room, user_can_view_room, + HtmlUiAction, JsBuilder, ThreadNav, }, reducer::{scope_from_room_wire, ScopeId}, state::AppState, @@ -575,6 +575,25 @@ async fn dispatch_ui_action( let viewer = session.map(|s| s.username.as_str()); thread_ui_copy_thread(state, &room, &thread_tag, ©_btn_id, viewer).await } + HtmlUiAction::CopyGardenRank { + room, + parent_path, + depth, + copy_btn_id, + external_hosts, + } => { + let viewer = session.map(|s| s.username.as_str()); + garden_ui_copy_rank( + state, + &room, + &parent_path, + depth, + ©_btn_id, + external_hosts, + viewer, + ) + .await + } HtmlUiAction::GraduateThread { room, thread_tag } => { let Some(session) = session else { return js_redirect("/login").into_response(); diff --git a/server/src/html/garden/copy.rs b/server/src/html/garden/copy.rs new file mode 100644 index 0000000000000000000000000000000000000000..271ea87c34c99e23ab1b0d8572632fdc41380b78 --- /dev/null +++ b/server/src/html/garden/copy.rs @@ -0,0 +1,199 @@ +//! Copy garden rankings to the clipboard as concise markdown (POST /ui + JsBuilder eval). + +use crate::form_template::template_json_compact; +use crate::html::forum::ThreadNav; +use crate::html::js_string_literal; +use crate::html::ui_action::HtmlUiAction; +use crate::html::{JsBuilder, ui_js_warn}; +use crate::path_types::ItemId; +use crate::reducer::scope_from_room_wire; +use crate::scope_rank::{ + build_children_rankings, build_rankings_for_item_set, external_root_host_items, + resolve_scope_recursive, ChildrenRankings, +}; +use crate::state::AppState; +use maud::{html, Markup}; + +use super::access::user_can_view_room; +use super::item::item_display_path; +use crate::reducer::{ContentState, ScopeId}; + +const COPY_BTN_ID: &str = "garden-rank-copy"; + +/// `POST /ui` + `__rpc__` from an inline button; response body is `eval`'d (same as forum copy). +fn garden_ui_fetch_onclick(rpc_compact_json: &str) -> String { + format!( + "fetch('/ui',{{method:'POST',headers:{{'Content-Type':'application/x-www-form-urlencoded'}},body:new URLSearchParams({{__rpc__:{}}}).toString(),credentials:'same-origin'}}).then(r=>r.text()).then(eval);return false", + js_string_literal(rpc_compact_json) + ) +} + +/// Concise markdown for ranked child groups (numbered lists + unranked bullets). +pub(crate) fn format_garden_rank_markdown(rankings: &ChildrenRankings) -> String { + let mut out = String::new(); + let multi = rankings.component_rankings.len() > 1; + for (ci, comp) in rankings.component_rankings.iter().enumerate() { + if ci > 0 { + out.push('\n'); + } + if multi { + out.push_str(&format!("### ordering {}\n\n", ci + 1)); + } + for (i, r) in comp.ranked.iter().enumerate() { + out.push_str(&format!( + "{}. {}\n", + i + 1, + item_display_path(r.item.as_str()) + )); + } + } + if !rankings.unranked_items.is_empty() { + if !out.is_empty() { + out.push('\n'); + } + for name in &rankings.unranked_items { + out.push_str(&format!("- {}\n", item_display_path(name.as_str()))); + } + } + out +} + +fn rankings_for_copy( + state_content: &crate::reducer::ContentState, + parent_path: &str, + depth: usize, + external_hosts: bool, +) -> ChildrenRankings { + if external_hosts { + let hosts = external_root_host_items(state_content); + return build_rankings_for_item_set(state_content, &hosts); + } + let parent = ItemId::parse(parent_path.trim()) + .unwrap_or_else(|| ItemId::ontology_root()) + .normalized_storage(); + let depth = depth.clamp(1, 5); + if depth > 1 { + let items = resolve_scope_recursive(state_content, &[parent.as_str().to_string()], depth); + build_rankings_for_item_set(state_content, &items) + } else { + build_children_rankings(state_content, &parent) + } +} + +pub(crate) async fn garden_ui_copy_rank( + state: &AppState, + room: &str, + parent_path: &str, + depth: usize, + copy_btn_id: &str, + external_hosts: bool, + viewer: Option<&str>, +) -> axum::response::Response { + let room = room.trim(); + let scope = scope_from_room_wire(room); + if let ScopeId::Room(ref rid) = scope { + let reduced = state.reduced.read().await; + if !user_can_view_room(&reduced, rid, viewer) { + return ui_js_warn("forbidden"); + } + } + + let reduced = state.reduced.read().await; + let empty = ContentState::default(); + let content = match &scope { + ScopeId::Public => reduced.public(), + ScopeId::Room(_) => reduced.content_for_scope(&scope).unwrap_or(&empty), + }; + let rankings = rankings_for_copy(content, parent_path, depth, external_hosts); + let text = format_garden_rank_markdown(&rankings); + drop(reduced); + + if text.is_empty() { + return ui_js_warn("nothing to copy"); + } + + JsBuilder::new() + .clipboard_write_text_and_label_btn(&text, copy_btn_id, "copied") + .into_response() +} + +pub(super) fn garden_rank_copy_button_markup( + nav: &ThreadNav, + parent_path: &str, + depth: usize, + external_hosts: bool, +) -> Markup { + let rpc = template_json_compact(&HtmlUiAction::CopyGardenRank { + room: nav.room_wire.clone(), + parent_path: parent_path.to_string(), + depth, + copy_btn_id: COPY_BTN_ID.to_string(), + external_hosts, + }) + .expect("CopyGardenRank serializes"); + html! { + button type="button" id=(COPY_BTN_ID) class="post-nav-btn ont-rank-copy-btn" title="Copy ranking as markdown" + onclick=(garden_ui_fetch_onclick(&rpc)) { + "copy" + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::path_types::ItemId; + use crate::ranking::RankedItem; + use crate::scope_rank::ScopedComponent; + + #[test] + fn markdown_single_component_and_unranked() { + let rankings = ChildrenRankings { + component_rankings: vec![ScopedComponent { + pairs: 1, + ranked: vec![ + RankedItem { + item: ItemId::parse("~/a").unwrap(), + score: 0.9, + }, + RankedItem { + item: ItemId::parse("~/b").unwrap(), + score: 0.1, + }, + ], + }], + unranked_items: vec![ItemId::parse("~/c").unwrap()], + }; + assert_eq!( + format_garden_rank_markdown(&rankings), + "1. ~/a\n2. ~/b\n\n- ~/c\n" + ); + } + + #[test] + fn markdown_multi_component_headers() { + let rankings = ChildrenRankings { + component_rankings: vec![ + ScopedComponent { + pairs: 1, + ranked: vec![RankedItem { + item: ItemId::parse("~/a").unwrap(), + score: 1.0, + }], + }, + ScopedComponent { + pairs: 1, + ranked: vec![RankedItem { + item: ItemId::parse("~/b").unwrap(), + score: 1.0, + }], + }, + ], + unranked_items: vec![], + }; + assert_eq!( + format_garden_rank_markdown(&rankings), + "### ordering 1\n\n1. ~/a\n\n### ordering 2\n\n1. ~/b\n" + ); + } +} diff --git a/server/src/html/garden/mod.rs b/server/src/html/garden/mod.rs index ee8696727e5473fe1fa913b8a7b9f3cb9c32d12f..69012a2c1d069e47fa611d63d3bd2a329fd6255d 100644 --- a/server/src/html/garden/mod.rs +++ b/server/src/html/garden/mod.rs @@ -2,6 +2,7 @@ mod access; mod browse; +mod copy; mod external; mod item; mod item_page; @@ -13,6 +14,7 @@ mod vote; #[cfg(test)] mod tests; +pub(crate) use copy::garden_ui_copy_rank; pub(crate) use external::external_resolver_status_markup; pub(crate) use pin::{encode_pin_cookie_value, GARDEN_PIN_COOKIE}; pub(crate) use vote::vote_compare_post_success_js; diff --git a/server/src/html/garden/render.rs b/server/src/html/garden/render.rs index ca546693ecb2bb9ae5fb370f02b860c943f604b9..eed80e807d77e6b4eeeb0c3f38d6372e91ad2852 100644 --- a/server/src/html/garden/render.rs +++ b/server/src/html/garden/render.rs @@ -25,6 +25,7 @@ use crate::{ use super::{ access::content_for_garden_view, browse::{garden_layout_meta, scoped_bc_path_for, GardenBrowsePath}, + copy::garden_rank_copy_button_markup, external::{external_frame_allowed, external_source_href, github_resolver_controls}, item::{child_depth_from_uri, item_code_label, item_display_path, item_href}, item_page::{build_item_page_view_model, sibling_nav_markup}, @@ -196,6 +197,15 @@ pub(super) async fn render_scope_view( " " span class="muted" { (format!("(depth {})", model.child_depth)) } } + @if total_children > 0 { + " " + (garden_rank_copy_button_markup( + &nav, + &item_display_path(&model.item), + model.child_depth, + false, + )) + } @if total_children >= 2 { " " a class="ont-vote-children-btn" href=(vote_pool_href(&nav, &model.item)) { diff --git a/server/src/html/garden/routes.rs b/server/src/html/garden/routes.rs index 8a0499576d9093dbac0fffa1cf2ed88187e14acb..31b61355b1ec75645d405e16ab6abf8205c66380 100644 --- a/server/src/html/garden/routes.rs +++ b/server/src/html/garden/routes.rs @@ -28,6 +28,7 @@ use crate::{ use super::{ access::{content_for_garden_view, room_not_found_page, room_scope_has_garden_content, user_can_view_room}, browse::{GardenBrowsePath, scoped_bc_path_external}, + copy::garden_rank_copy_button_markup, item::{item_display_path, item_href}, render::render_scope_view, }; @@ -52,7 +53,13 @@ pub async fn garden_index( html! { @let root_path = OntologyPath::root(); nav class="breadcrumb" { (bc_path(&root_path)) } - h2 { "paths" } + h2 { + "paths" + @if !(child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty()) { + " " + (garden_rank_copy_button_markup(&nav, "~/", 1, false)) + } + } @if child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty() { p class="muted" { "no items yet" } } @else { @@ -137,7 +144,13 @@ pub async fn external_garden_index( "view-ontology view-ontology-light", html! { nav class="breadcrumb" { (bc_path_external(&ext_path)) } - h2 { "external paths" } + h2 { + "external paths" + @if !(child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty()) { + " " + (garden_rank_copy_button_markup(&nav, "", 1, true)) + } + } p class="muted" { "Items outside slug.social use the " code { "-/" } " prefix followed by the full " code { "https://…" } " URL (legacy " code { "-/host/path" } " still works)." } @if child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty() { p class="muted" { "no external items indexed yet" } @@ -272,7 +285,13 @@ pub async fn room_external_garden_index( "view-ontology view-ontology-light", html! { nav class="breadcrumb" { (scoped_bc_path_external(&ext_path, &nav)) } - h2 { "external paths" } + h2 { + "external paths" + @if !(child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty()) { + " " + (garden_rank_copy_button_markup(&nav, "", 1, true)) + } + } @if child_rankings.component_rankings.is_empty() && child_rankings.unranked_items.is_empty() { p class="muted" { "no external items indexed yet" } } @else { diff --git a/server/src/html/mod.rs b/server/src/html/mod.rs index d7014fc7f934e5b0c7fb47ebf00cb4ef50d306c2..645d54f2e117ba901e02ed958ada6ff69a78ae34 100644 --- a/server/src/html/mod.rs +++ b/server/src/html/mod.rs @@ -37,8 +37,8 @@ pub(crate) use forum::{ user_can_post_room, user_can_view_room, }; pub(crate) use garden::{ - encode_pin_cookie_value, external_resolver_status_markup, vote_compare_post_success_js, - GARDEN_PIN_COOKIE, + encode_pin_cookie_value, external_resolver_status_markup, garden_ui_copy_rank, + vote_compare_post_success_js, GARDEN_PIN_COOKIE, }; pub use garden::{ external_garden_index, external_ontology_path, garden_index, ontology_path, diff --git a/server/src/html/ui_action.rs b/server/src/html/ui_action.rs index 5cf3168fb74e7654215cd9ff8942c6ed63fd0002..7dc3db062954370b5504fc311c0ab24bab569f80 100644 --- a/server/src/html/ui_action.rs +++ b/server/src/html/ui_action.rs @@ -118,6 +118,18 @@ pub enum HtmlUiAction { thread_tag: String, copy_btn_id: String, }, + /// Copy garden child ranking as a concise markdown list to the clipboard. + CopyGardenRank { + room: String, + /// Parent item path (storage or display). Ignored when `external_hosts` is true. + parent_path: String, + #[serde(default = "default_garden_rank_depth")] + depth: usize, + copy_btn_id: String, + /// When true, copy rankings for external host roots (`/-/` index), not parent children. + #[serde(default)] + external_hosts: bool, + }, /// Publish a private-room thread to the public forum (Manage only). GraduateThread { room: String, @@ -125,6 +137,10 @@ pub enum HtmlUiAction { }, } +fn default_garden_rank_depth() -> usize { + 1 +} + #[derive(Debug, Error)] pub enum HtmlUiParseError { #[error("missing __rpc__ field")] @@ -272,4 +288,57 @@ mod tests { } ); } + + #[test] + fn copy_garden_rank_round_trip() { + let template = serde_json::json!({ + "action": "copy_garden_rank", + "room": "public", + "parent_path": "~/topic", + "depth": 2, + "copy_btn_id": "garden-rank-copy", + }); + let mut form = HashMap::new(); + form.insert( + UI_RPC_FIELD.to_string(), + serde_json::to_string(&template).unwrap(), + ); + let a = parse_html_ui_from_form(&form).unwrap(); + assert_eq!( + a, + HtmlUiAction::CopyGardenRank { + room: "public".into(), + parent_path: "~/topic".into(), + depth: 2, + copy_btn_id: "garden-rank-copy".into(), + external_hosts: false, + } + ); + } + + #[test] + fn copy_garden_rank_defaults_depth_and_external_hosts() { + let template = serde_json::json!({ + "action": "copy_garden_rank", + "room": "public", + "parent_path": "~/", + "copy_btn_id": "garden-rank-copy", + }); + let mut form = HashMap::new(); + form.insert( + UI_RPC_FIELD.to_string(), + serde_json::to_string(&template).unwrap(), + ); + let a = parse_html_ui_from_form(&form).unwrap(); + assert_eq!( + a, + HtmlUiAction::CopyGardenRank { + room: "public".into(), + parent_path: "~/".into(), + depth: 1, + copy_btn_id: "garden-rank-copy".into(), + external_hosts: false, + } + ); + } } diff --git a/server/tests/integration_ui.rs b/server/tests/integration_ui.rs index d242abff5769cc704b3c8070d7456e5788c31a45..6b1475b773106a2dd3f326475c9fb4cc727f6b4b 100644 --- a/server/tests/integration_ui.rs +++ b/server/tests/integration_ui.rs @@ -490,3 +490,71 @@ async fn test_vote_compare_post_rejects_over_max_ratio() { ); } +#[tokio::test] +async fn test_copy_garden_rank_returns_clipboard_js_with_markdown() { + let (addr, _tmp, _log, _handle) = create_test_server().await; + let client = reqwest::Client::new(); + let bearer = test_bearer(); + + let seed = rpc_batch( + &client, + addr, + Some(&bearer), + serde_json::json!([{ + "Post": { + "room": "public", + "thread_tag": "copy-rank-ui", + "text": "# copy-rank-ui\n\n~/copy-a {a}\n~/copy-b {b}\n~/copy-c {c}\n{vote}\n~/copy-a 2:1 ~/copy-b\n", + "return_rank_diff": false + } + }]), + ) + .await; + assert_eq!(seed["results"][0]["ok"], true, "seed: {:?}", seed); + + let page = client + .get(format!("http://{addr}/~")) + .send() + .await + .unwrap(); + assert!(page.status().is_success()); + let html = page.text().await.unwrap(); + assert!( + html.contains("id=\"garden-rank-copy\"") && html.contains("copy_garden_rank"), + "garden index should include copy button + action payload" + ); + + let rpc = serde_json::json!({ + "action": "copy_garden_rank", + "room": "public", + "parent_path": "~/", + "depth": 1, + "copy_btn_id": "garden-rank-copy", + }) + .to_string(); + let resp = client + .post(format!("http://{addr}/ui")) + .header("Authorization", format!("Bearer {bearer}")) + .form(&[("__rpc__", rpc.as_str())]) + .send() + .await + .unwrap(); + assert_eq!(resp.status(), reqwest::StatusCode::OK); + assert_eq!( + resp.headers() + .get(reqwest::header::CONTENT_TYPE) + .and_then(|v| v.to_str().ok()), + Some("text/javascript; charset=utf-8") + ); + let js = resp.text().await.unwrap(); + assert!( + js.contains("navigator.clipboard.writeText") && js.contains("garden-rank-copy"), + "expected clipboard JsBuilder snippet, got: {js}" + ); + assert!( + js.contains("1. ~/copy-a") && js.contains("2. ~/copy-b") && js.contains("- ~/copy-c"), + "expected concise markdown ranking in clipboard payload, got: {js}" + ); + assert!(js.contains("\"copied\""), "expected button label flip to copied"); +} + diff --git a/test/browser_public_garden.clj b/test/browser_public_garden.clj index 5dd49f1f70c870e25a2a9f5348f0bdb85647e897..8ceb532c664f9fc3d6f66a451e5ea5eaa1671007 100644 --- a/test/browser_public_garden.clj +++ b/test/browser_public_garden.clj @@ -73,6 +73,7 @@ (core/with-playwright [pw] (core/with-browser [browser (core/launch-chromium pw {:headless true :channel "chrome"})] (core/with-context [ctx (core/new-context browser)] + (core/context-grant-permissions! ctx ["clipboard-read" "clipboard-write"]) (core/with-page [pg (core/new-page-from-context ctx)] (page/navigate pg (str base-url "/login")) (is (wait-for-text pg "body" "@alice" 15000) "alice session after login") @@ -84,7 +85,12 @@ (is (wait-for-text pg "body" "~/br-pub-b" 10000) "ranked list shows ~/br-pub-b") (is (wait-for-text pg "body" "unranked" 10000) "unranked section present") (is (wait-for-text pg "body" "~/br-pub-c" 10000) - "unranked list shows ~/br-pub-c")))))) + "unranked list shows ~/br-pub-c") + (is (wait-for-text pg "#garden-rank-copy" "copy" 5000) + "garden ranking copy button visible") + (locator/click (page/locator pg "#garden-rank-copy")) + (is (wait-for-text pg "#garden-rank-copy" "copied" 10000) + "copy button flips to copied after POST /ui eval")))))) (finally (when-some [s @!server] (common/kill-server s)) Side B — contributor: tommy-mor Side B — commit message: [bda5f8aa] Remove legacy evidence projection; Evidence envelopes only. Epoch and commit pages no longer invent history from bare GitDiscovery rows. Production ledger will be wiped to re-emit under the current schema. Co-authored-by: Cursor Side B — unified diff (full patch): diff --git a/constitution.py b/constitution.py index 4dd5b9dfbba231d46289c490f91b1dd5b1018bcf..26ba130e885e0e69fb7874ca5c3f07f42100a150 100644 --- a/constitution.py +++ b/constitution.py @@ -210,10 +210,10 @@ class Emission: distributions: dict # author -> amount str ranking: dict # author -> score str models_used: list - discovery_snapshot_id: str = "" # empty only for pre-discovery ledger history - evidence_schema_version: int = 1 - ranking_run_id: str = "" - ranking_event_id: str = "" + discovery_snapshot_id: str + evidence_schema_version: int + ranking_run_id: str + ranking_event_id: str @event @@ -502,26 +502,6 @@ def _epochs_in_ledger() -> list[int]: return sorted(epochs) -def _legacy_commit_row(commit_id: str) -> tuple[GitDiscovery | None, dict | None]: - for discovery in store.read(): - if not isinstance(discovery, GitDiscovery): - continue - for commit in discovery.commits: - if commit_id_for_oid(commit["oid"]) == commit_id: - return discovery, commit - return None, None - - -def _legacy_observation(commit_id: str) -> tuple[GitDiscovery | None, dict | None]: - for discovery in store.read(): - if not isinstance(discovery, GitDiscovery): - continue - for obs in discovery.observations: - if commit_id_for_oid(obs["oid"]) == commit_id: - return discovery, obs - return None, None - - 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. @@ -2040,7 +2020,7 @@ def _strip_heavy_fields(obj: dict) -> dict: @app.get("/api/ledger") async def get_ledger(offset: int = 0, limit: int = 100, full: int = 0): - """List of ledger dicts (backward-compatible). Heavy blobs stripped unless full=1.""" + """List of ledger dicts. Heavy blobs stripped unless full=1.""" limit = max(1, min(limit, 500)) rows = [] for e in store.read()[offset:offset + limit]: @@ -2274,23 +2254,25 @@ async def epochs_index(): epochs = _epochs_in_ledger() rows = [] for epoch in epochs: - discovery = _discovery_for_epoch(epoch) emission = _emission_for_epoch(epoch) - evidence_n = sum( - 1 for e in evidence_by_kind() if e.epoch == epoch + evidence_n = sum(1 for e in evidence_by_kind() if e.epoch == epoch) + disc = next( + ( + e for e in evidence_by_kind("git.discovery_completed") + if e.epoch == epoch + ), + None, ) detail = [] - if discovery: + if disc: detail.append( - f"{len(discovery.commits)} eligible / " - f"{len(discovery.observations)} observed" + f"{disc.payload.get('eligible_count', 0)} eligible / " + f"{disc.payload.get('observation_count', 0)} observed" ) if emission: detail.append(f"emitted {emission.total_emitted}") if evidence_n: detail.append(f"{evidence_n} evidence events") - elif discovery or emission: - detail.append("legacy (no Evidence envelopes)") rows.append(["li", _a(_evidence_path("epoch", str(epoch)), f"epoch {epoch}"), " — ", @@ -2307,37 +2289,37 @@ async def epochs_index(): @app.get("/epochs/{epoch}") async def epoch_detail(epoch: int): - discovery = _discovery_for_epoch(epoch) emission = _emission_for_epoch(epoch) evidence_rows = [e for e in evidence_by_kind() if e.epoch == epoch] + if not evidence_rows and emission is None: + return _evidence_page(f"epoch {epoch}", [ + _evidence_nav(), + ["h1", f"epoch {epoch}"], + ["p.note", "No evidence for this epoch."], + ]) + commit_evs = [e for e in evidence_rows if e.kind == "git.commit"] comparison_evs = [e for e in evidence_rows if e.kind == "comparison.input"] judgment_evs = [e for e in evidence_rows if e.kind == "llm.judgment"] + discovery_ev = next( + (e for e in evidence_rows if e.kind == "git.discovery_completed"), None + ) ranking_started = next( (e for e in evidence_rows if e.kind == "ranking.started"), None ) ranking_completed = next( (e for e in evidence_rows if e.kind == "ranking.completed"), None ) - legacy = not evidence_rows and (discovery is not None or emission is not None) - - commit_links: list[tuple[str, str]] = [] - if commit_evs: - for e in commit_evs: - cid = e.payload.get("commit_id") or "" - label = ( - f"{e.payload.get('oid', cid)[:24]} " - f"({e.payload.get('contributor', '?')})" - ) - commit_links.append((label, _evidence_path("commit", cid))) - elif discovery: - for c in discovery.commits: - cid = commit_id_for_oid(c["oid"]) - commit_links.append(( - f"{c['oid'][:24]} ({c.get('contributor', '?')})", - _evidence_path("commit", cid), - )) + commit_links = [ + ( + f"{e.payload.get('oid', e.payload.get('commit_id', ''))[:24]} " + f"({e.payload.get('contributor', '?')})", + _evidence_path("commit", e.payload["commit_id"]), + ) + for e in commit_evs + if e.payload.get("commit_id") + ] comparison_links = [ ( e.payload.get("summary") or e.payload.get("comparison_id", e.event_id), @@ -2360,16 +2342,13 @@ async def epoch_detail(epoch: int): ] excluded = [] - if discovery: - for obs in discovery.observations: + if discovery_ev: + for obs in discovery_ev.payload.get("observations") or []: if obs.get("eligible"): continue oid = obs.get("oid", "?") reason = obs.get("exclusion_reason") or "excluded" - excluded.append(["li", - f"{oid[:28]} — {reason} — ", - ["span.note", "legacy evidence unavailable"], - ]) + excluded.append(["li", f"{oid[:28]} — {reason}"]) ranking_nodes: list = [] if ranking_completed: @@ -2388,21 +2367,10 @@ async def epoch_detail(epoch: int): indent=2, sort_keys=True, )], ] - elif emission: - if legacy and len(emission.ranking or {}) <= 1: - ranking_nodes.append(["p.note", - "Single-contributor epoch — no LLM judgments." - ]) - ranking_nodes.extend([ - ["p", "Projected from Emission (no ranking Evidence event)."], - ["pre.blob", json.dumps(emission.ranking, indent=2, sort_keys=True)], - ]) + elif ranking_started: + ranking_nodes = [["p.note", f"Ranking started: {ranking_started.event_id}"]] else: - ranking_nodes = [["p.note", "No ranking recorded."]] - if ranking_started and not ranking_completed: - ranking_nodes.insert(0, ["p.note", - f"Ranking started: {ranking_started.event_id}" - ]) + ranking_nodes = [["p.note", "No ranking evidence."]] if emission: emission_node = _dl_rows([ @@ -2411,44 +2379,41 @@ async def epoch_detail(epoch: int): ("pool_after", emission.pool_after), ("discovery_snapshot_id", emission.discovery_snapshot_id), ("ranking_run_id", emission.ranking_run_id or None), + ("ranking_event_id", emission.ranking_event_id or None), ("models_used", ", ".join(emission.models_used or [])), ("distributions", json.dumps(emission.distributions, sort_keys=True)), ]) else: emission_node = ["p.note", "No emission for this epoch."] - single_contributor = False - if discovery: - single_contributor = len({c.get("contributor") for c in discovery.commits}) <= 1 - elif emission: - single_contributor = len(emission.ranking or {}) <= 1 + 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." body = [ _evidence_nav(), ["div.eyebrow", f"epoch {epoch}"], ["h1", f"epoch {epoch}"], ] - if legacy: - body.append(["p.note", - "Legacy epoch: projected from GitDiscovery/Emission without Evidence " - "envelopes. Eligible commits use discovery patches; discarded observation " - "metadata is marked legacy evidence unavailable. Single-contributor " - "epochs have no LLM judgments." - ]) - if discovery: + if discovery_ev: body.extend([ ["h2", "discovery"], _dl_rows([ - ("snapshot_id", discovery.snapshot_id), - ("config_digest", discovery.config_digest), - ("initial_snapshot", discovery.initial_snapshot), - ("observations", len(discovery.observations)), - ("eligible", len(discovery.commits)), + ("snapshot_id", discovery_ev.payload.get("snapshot_id")), + ("config_digest", discovery_ev.payload.get("config_digest")), + ("observations", discovery_ev.payload.get("observation_count")), + ("eligible", discovery_ev.payload.get("eligible_count")), + ("event", _a( + _evidence_path("event", discovery_ev.event_id), + discovery_ev.event_id, + )), ]), ]) - no_comparisons_note = "No comparisons." - if single_contributor: - no_comparisons_note += " Single-contributor — no LLM judgments." body.extend([ ["h2", "commits"], _link_list(commit_links), @@ -2471,92 +2436,42 @@ async def epoch_detail(epoch: int): @app.get("/commits/{commit_id}") async def commit_detail(commit_id: str): ev = find_evidence_payload("git.commit", "commit_id", commit_id) - discovery, legacy_row = (None, None) if not ev: - discovery, legacy_row = _legacy_commit_row(commit_id) - if not ev and not legacy_row: - discovery, obs = _legacy_observation(commit_id) - if obs is not None: - epoch = discovery.epoch if discovery else "?" - return _evidence_page(f"commit {commit_id[:24]}", [ - _evidence_nav( - _a(_evidence_path("epoch", str(epoch)), f"epoch {epoch}") - ), - ["div.eyebrow", "commit"], - ["h1", commit_id], - ["p.note", "legacy evidence unavailable"], - _dl_rows([ - ("oid", obs.get("oid")), - ("eligible", obs.get("eligible")), - ("exclusion_reason", obs.get("exclusion_reason")), - ("epoch", str(epoch)), - ]), - ]) return _evidence_page("commit not found", [ _evidence_nav(), ["h1", "commit not found"], ["p", commit_id], ]) - if ev: - p = ev.payload - epoch = ev.epoch - oid = p.get("oid", "") - contributor = p.get("contributor", "") - message = _blob_text(p.get("message")) - patch = _blob_text(p.get("patch")) - meta = _dl_rows([ + p = ev.payload + epoch = ev.epoch + return _evidence_page(f"commit {commit_id[:24]}", [ + _evidence_nav(_a(_evidence_path("epoch", str(epoch)), f"epoch {epoch}")), + ["div.eyebrow", "commit"], + ["h1", commit_id], + _dl_rows([ ("commit_id", commit_id), - ("oid", oid), - ("contributor", contributor), + ("oid", p.get("oid", "")), + ("contributor", p.get("contributor", "")), ("patch_sha256", p.get("patch_sha256")), ("patch_identity", p.get("patch_identity")), ("committer_timestamp_ms", p.get("committer_timestamp_ms")), ("evidence_event", _a(_evidence_path("event", ev.event_id), ev.event_id)), ("epoch", _a(_evidence_path("epoch", str(epoch)), str(epoch))), - ]) - legacy_note = None - else: - assert legacy_row is not None and discovery is not None - epoch = discovery.epoch - oid = legacy_row.get("oid", "") - contributor = legacy_row.get("contributor", "") - message = legacy_row.get("message") or "" - patch = legacy_row.get("patch") or "" - meta = _dl_rows([ - ("commit_id", commit_id), - ("oid", oid), - ("contributor", contributor), - ("patch_sha256", legacy_row.get("patch_sha256")), - ("patch_identity", legacy_row.get("patch_identity")), - ("committer_timestamp_ms", legacy_row.get("committer_timestamp_ms")), - ("epoch", _a(_evidence_path("epoch", str(epoch)), str(epoch))), - ("source", "legacy GitDiscovery projection"), - ]) - legacy_note = ["p.note", "Projected from GitDiscovery — Evidence envelope absent."] - return _evidence_page(f"commit {commit_id[:24]}", [ - _evidence_nav(_a(_evidence_path("epoch", str(epoch)), f"epoch {epoch}")), - ["div.eyebrow", "commit"], - ["h1", commit_id], - *([legacy_note] if legacy_note else []), - meta, + ]), ["p", _a(f"/commits/{commit_id}/patch", "download patch")], ["h2", "message"], - _pre_blob(message), + _pre_blob(_blob_text(p.get("message"))), ["h2", "patch"], - _pre_blob(patch), + _pre_blob(_blob_text(p.get("patch"))), ]) @app.get("/commits/{commit_id}/patch") async def commit_patch_download(commit_id: str): ev = find_evidence_payload("git.commit", "commit_id", commit_id) - if ev: - raw = _decode_blob(ev.payload.get("patch")) or _blob_text(ev.payload.get("patch")).encode() - else: - _, row = _legacy_commit_row(commit_id) - if not row: - return PlainTextResponse("not found", status_code=404) - raw = (row.get("patch") or "").encode("utf-8") + if not ev: + return PlainTextResponse("not found", status_code=404) + raw = _decode_blob(ev.payload.get("patch")) or _blob_text(ev.payload.get("patch")).encode() return Response( content=raw, media_type="text/plain; charset=utf-8", @@ -3226,7 +3141,9 @@ async def watch(): ["div.controls", ["button#play", {"type": "button", "disabled": "true"}, "▶ Play live feed"], ["button#pause", {"type": "button"}, "Ⅱ Pause feed"], - ["span.note", "Pause stops local updates; the constitutional process continues."], + ["span.note", + "Play/pause only affect this browser feed — they do not run or stop emission. " + "The server emits at each epoch boundary; status above is that process."], ], ], ["section.panel", diff --git a/tests/integration.clj b/tests/integration.clj index 204b0fedfbad57846205cb140c4ed9406b5f8e0e..11140e95a8cd86768a661a30e6b29a3ddfc95fcc 100644 --- a/tests/integration.clj +++ b/tests/integration.clj @@ -247,7 +247,10 @@ :decay_rate "0.003253356063468" :distributions {"alice" "381.4282558872" "bob" "190.7141279436"} :ranking {"alice" "0.6666" "bob" "0.3334"} - :models_used ["mock/chat-v1" "mock/chat-v2"]}] + :models_used ["mock/chat-v1" "mock/chat-v2"] + :evidence_schema_version 2 + :ranking_run_id "seed-rank" + :ranking_event_id "seed-rank-ev"}] (spit path (str (json/generate-string entry) "\n")))) ;; --------------------------------------------------------------------------- diff --git a/tests/test_evidence.py b/tests/test_evidence.py index 76adcd343eec3a65dec58fda93b068356fb1adcd..7cb74fd7fb1bcd0ab17d2cbe2e6ca7e61e164221 100644 --- a/tests/test_evidence.py +++ b/tests/test_evidence.py @@ -1,4 +1,4 @@ -"""HTML evidence graph: byte fidelity, resume, legacy projection, private ack.""" +"""HTML evidence graph: byte fidelity, resume, and Evidence-only pages.""" from __future__ import annotations @@ -86,55 +86,10 @@ def test_html_evidence_pages_escape_and_link(evidence_store): assert patch_resp.headers["content-disposition"].startswith("attachment") -def test_legacy_epoch_projects_from_gitdiscovery_without_evidence(evidence_store): - oid = "sha1:" + "b" * 40 - discovery = c.GitDiscovery( - schema_version=1, - epoch=3, - snapshot_id="legacy-snap", - timestamp_ms=1, - config_digest="d", - initial_snapshot=True, - configuration={"repositories": [], "contributors": {}}, - repositories=[], - observations=[{ - "oid": oid, - "eligible": False, - "exclusion_reason": "before_genesis", - "first_sources": [], - }, { - "oid": "sha1:" + "c" * 40, - "eligible": True, - "exclusion_reason": None, - "first_sources": [], - }], - commits=[{ - "oid": "sha1:" + "c" * 40, - "contributor": "tommy-mor", - "message": "eligible", - "patch": "diff --git a/x b/x\n", - }], - ) - emission = c.Emission( - epoch=3, - timestamp_ms=2, - pool_before="1", - total_emitted="0.1", - pool_after="0.9", - decay_rate="0.1", - distributions={"tommy-mor": "0.1"}, - ranking={"tommy-mor": "1"}, - models_used=[], - discovery_snapshot_id="legacy-snap", - ) - asyncio.run(c.store.append(discovery)) - asyncio.run(c.store.append(emission)) - html = asyncio.run(c.epoch_detail(3)).body.decode() - assert "legacy" in html.lower() - assert "Single-contributor" in html or "no LLM" in html - excluded_id = c.commit_id_for_oid(oid) - excluded_html = asyncio.run(c.commit_detail(excluded_id)).body.decode() - assert "legacy evidence unavailable" in excluded_html.lower() +def test_commit_without_evidence_is_not_found(evidence_store): + html = asyncio.run(c.commit_detail("c_missing")).body.decode() + assert "commit not found" in html + assert "legacy" not in html.lower() def test_ranking_resume_skips_duplicate_provider_calls(evidence_store, monkeypatch): @@ -202,6 +157,10 @@ def test_epochs_index_lists_epochs(evidence_store): distributions={}, ranking={}, models_used=[], + discovery_snapshot_id="snap", + evidence_schema_version=c.EVIDENCE_SCHEMA_VERSION, + ranking_run_id="r", + ranking_event_id="e", ))) html = asyncio.run(c.epochs_index()).body.decode() assert "/epochs/3" in html