flagon-io/g1t

Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.

Inbox: the events service tells people what needs them as events arrive1d ago		1	//! The inbox, kept beside the event log. See `g1t_contracts::inbox`.
		2	//!
Inbox: threads, reasons, subscriptions and watching1d ago		3	//! As each batch arrives from the bus, the events that tell someone are
		4	//! read against what they name (the work service's `inbox_subject`), who
		5	//! subscribes to it and who watches its repository (subscriptions.rs), and
		6	//! each person told gets their thread about it brought to the top, unread,
		7	//! with a line added to its history. Who is told is worked out in
		8	//! [`notices`], from the event, its subject and that audience alone:
Inbox: the events service tells people what needs them as events arrive1d ago		9	//!
Inbox: threads, reasons, subscriptions and watching1d ago		10	//! | Event | Who | Reason | Severity |
		11	//! | --- | --- | --- | --- |
		12	//! | `agent.asked`, `pull.stalled` | the pull request's owner, and its issue's owner and assignees | agent | warning |
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		13	//! | `pull.review_requested` | the reviewers asked, and the people each team asked tells | review_requested | warning |
Inbox: threads, reasons, subscriptions and watching1d ago		14	//! | `issue.assigned`, `pull.assigned` | the people newly assigned | assign | info |
		15	//! | `checks.completed`, failed or errored | the pull request's owner | ci_activity | error |
		16	//! | `workflow.completed`, failed | the pull request's owner, or whoever pushed | ci_activity | error |
		17	//! | `deployment.failed` | the pull request's owner, or whoever pushed; watchers | ci_activity | error |
		18	//! | `deployment.succeeded` after a failure | the same | ci_activity | success |
		19	//! | `review.completed` by g1t | the pull request's owner | author | success, or info for changes asked |
		20	//! | `pull.ready` for a change g1t made | whoever asked g1t for it | author | success |
		21	//! | `pull.merged`, `pull.closed`, `issue.closed`, `issue.reopened` | everyone subscribed | state_change | success for a merge, else info |
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		22	//! | `comment.created` | everyone mentioned, the people of teams mentioned, then everyone subscribed | mention, team_mention, or why they are subscribed | info (success for an approval) |
		23	//! | `issue.opened`, `pull.opened` | whoever was assigned, asked to review or mentioned in its description (people and teams); watchers | assign, review_requested, mention, team_mention, subscribed | info |
Inbox: the events service tells people what needs them as events arrive1d ago		24	//!
Inbox: threads, reasons, subscriptions and watching1d ago		25	//! Watchers of a repository at `all` (or `custom`, for the kinds they
		26	//! chose) hear of every issue and pull request opened, commented on,
		27	//! closed, reopened or merged, and of deployments. Anyone who ignores the
		28	//! thread or the repository hears of nothing on it; anyone who
		29	//! unsubscribed hears only of what is asked of them.
		30	//!
		31	//! Nobody is told of what they did themselves, though an outcome they set
		32	//! off (checks, a workflow, a deployment, g1t's work) is theirs to hear of.
		33	//! g1t is never told. A failure here is logged and the batch goes on: the
		34	//! bus never waits on the inbox, so an item can be missed, but nothing else
		35	//! is held up.
Inbox: the events service tells people what needs them as events arrive1d ago		36
		37	use std::collections::{HashMap, HashSet};
		38
		39	use g1t_contracts::credentials::Principal;
		40	use g1t_contracts::events::{Event, WorkspaceRenamed};
		41	use g1t_contracts::identity::{AGENT_ID, UsernamesArgs};
		42	use g1t_contracts::inbox::*;
		43	use g1t_contracts::repos::{PathByIdArgs, ReadableArgs, Repo, RepoPath};
		44	use g1t_contracts::time::rfc3339;
		45	use g1t_contracts::{new_id, system};
		46	use g1t_kit::now_ms;
		47	use serde::Deserialize;
		48	use worker::wasm_bindgen::JsValue;
Inbox: threads, reasons, subscriptions and watching1d ago		49	use worker::{D1Database, D1PreparedStatement, Fetcher, Result};
		50
		51	use crate::subscriptions::{self, Audience};
Inbox: the events service tells people what needs them as events arrive1d ago		52
		53	/// Items marked done are kept this long, then removed.
		54	pub const DONE_DAYS: u32 = 30;
		55	/// No item is kept longer than this, unless it was saved.
		56	pub const MAX_DAYS: u32 = 180;
		57	/// Unread warnings shown ahead of everything else on the first page.
		58	const MAX_RANKED: u32 = 20;
		59	const MAX_TITLE: usize = 200;
		60	const MAX_BODY: usize = 300;
		61
		62	/// What the inbox asks about an event before deciding who is told.
		63	#[derive(Debug, PartialEq, Eq)]
		64	pub struct Wanted {
		65	pub repo_id: String,
		66	/// The issue or pull request, when the event names one.
		67	pub number: Option<u32>,
		68	pub comment_id: Option<String>,
		69	}
		70
		71	/// One person to tell, and what.
		72	#[derive(Debug, PartialEq, Eq)]
		73	pub struct Notice {
		74	pub username: String,
Inbox: threads, reasons, subscriptions and watching1d ago		75	pub reason: Reason,
Inbox: the events service tells people what needs them as events arrive1d ago		76	pub severity: Severity,
		77	pub title: String,
		78	pub body: String,
		79	}
		80
		81	/// Who did it, as far as is known.
		82	#[derive(Debug, Default)]
		83	pub struct Actor {
		84	pub id: Option<String>,
		85	pub username: Option<String>,
		86	}
		87
		88	impl Actor {
		89	fn is(&self, person: &Principal) -> bool {
		90	self.id.as_deref().is_some_and(|id| id == person.id) || self.is_named(&person.username)
		91	}
		92
		93	fn is_named(&self, username: &str) -> bool {
		94	self.username.as_deref().is_some_and(|name| name.eq_ignore_ascii_case(username))
		95	}
Inbox: threads, reasons, subscriptions and watching1d ago		96
		97	/// A person's name, for a title: never g1t's ids.
		98	fn name(&self) -> Option<&str> {
		99	self.username.as_deref().filter(|name| !is_g1t(name))
		100	}
Inbox: the events service tells people what needs them as events arrive1d ago		101	}
		102
Inbox: threads, reasons, subscriptions and watching1d ago		103	pub(crate) fn is_g1t(username: &str) -> bool {
Inbox: the events service tells people what needs them as events arrive1d ago		104	username.eq_ignore_ascii_case(system::USERNAME) || username.eq_ignore_ascii_case("g1t-agent")
		105	}
		106
Inbox: threads, reasons, subscriptions and watching1d ago		107	pub(crate) fn is_g1t_id(id: &str) -> bool {
Inbox: the events service tells people what needs them as events arrive1d ago		108	system::is_system_id(id) || id == AGENT_ID
		109	}
		110
Inbox: threads, reasons, subscriptions and watching1d ago		111	/// Events that end what an agent was waiting on a person for: it picked
		112	/// back up, its head moved, a merge was asked for, or it is over.
		113	const RESUMES: [&str; 5] = ["pull.resumed", "pull.updated", "pull.merge_requested", "pull.merged", "pull.closed"];
		114
Inbox: the events service tells people what needs them as events arrive1d ago		115	/// The issue or pull request an event names, and what to read for it.
		116	/// None for events the inbox does not tell anyone of.
		117	pub fn wants(event: &Event) -> Option<Wanted> {
		118	let data = &event.data;
		119	let text = |key: &str| data[key].as_str().filter(|value| !value.is_empty()).map(str::to_owned);
		120	let number = |key: &str| data[key].as_u64().and_then(|n| u32::try_from(n).ok());
		121	let repo_id = text("repoId").or_else(|| event.repo_id.clone())?;
		122	let on = |number: Option<u32>, comment_id: Option<String>| {
		123	Some(Wanted {
		124	repo_id: repo_id.clone(),
		125	number,
		126	comment_id,
		127	})
		128	};
		129	match event.kind.as_str() {
Inbox: threads, reasons, subscriptions and watching1d ago		130	"agent.asked" | "pull.stalled" | "pull.merged" | "pull.closed" | "pull.ready" | "pull.opened"
		131	| "pull.review_requested" | "pull.assigned" | "issue.opened" | "issue.closed" | "issue.reopened"
		132	| "issue.assigned" => on(Some(number("number")?), None),
Inbox: the events service tells people what needs them as events arrive1d ago		133	"checks.completed" => match data["status"].as_str() {
		134	Some("failed" | "errored") => on(Some(number("number")?), None),
		135	_ => None,
		136	},
		137	"review.completed" => match data["verdict"].as_str() {
		138	Some("approve" | "request_changes") => on(Some(number("number")?), None),
		139	_ => None,
		140	},
		141	"workflow.completed" => match data["conclusion"].as_str() {
		142	Some("failure") => on(number("pull"), None),
		143	_ => None,
		144	},
Inbox: threads, reasons, subscriptions and watching1d ago		145	"deployment.failed" | "deployment.succeeded" => on(number("number"), None),
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		146	// A workflow run's jobs wait for their environment's reviewers.
		147	"deployment.review_requested" => on(None, None),
Inbox: the events service tells people what needs them as events arrive1d ago		148	"comment.created" => on(Some(number("number")?), Some(text("commentId")?)),
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		149	// Security alerts are threads of their own, not of an issue.
		150	kind if SECURITY_EVENTS.contains(&kind) => on(None, None),
Inbox: the events service tells people what needs them as events arrive1d ago		151	_ => None,
		152	}
		153	}
		154
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		155	/// The security service's events the inbox tells people of: new alerts,
		156	/// and push protection bypasses asked for and decided. Fixes and
		157	/// dismissals are on the Security page and in webhooks.
		158	pub const SECURITY_EVENTS: [&str; 5] = [
		159	"secret_scanning_alert.created",
		160	"code_scanning_alert.created",
		161	"vulnerability_alert.created",
		162	"secret_scanning.bypass_requested",
		163	"secret_scanning.bypass_reviewed",
		164	];
		165
Inbox: threads, reasons, subscriptions and watching1d ago		166	/// Where an event's items go: which thread, what it is, and where it is.
		167	#[derive(Clone, Debug, PartialEq, Eq)]
		168	pub struct Thread {
		169	pub key: String,
		170	pub kind: Option<SubjectKind>,
		171	pub number: Option<u32>,
		172	pub run_id: Option<String>,
		173	/// A path, for a subject with a page of its own.
		174	pub link: Option<String>,
		175	}
		176
		177	/// The thread key of an issue or pull request.
		178	pub fn numbered_thread(repo_id: &str, number: u32) -> String {
		179	format!("{repo_id}#{number}")
		180	}
		181
		182	/// The thread an event's items go to.
		183	pub fn thread_of(event: &Event, wanted: &Wanted, subject: Option<&InboxSubject>) -> Thread {
		184	let data = &event.data;
		185	let text = |key: &str| data[key].as_str().filter(|value| !value.is_empty()).map(str::to_owned);
		186	match event.kind.as_str() {
		187	// A project's production, or one pull request's preview.
		188	"deployment.failed" | "deployment.succeeded" => {
		189	let which = wanted.number.map_or_else(|| "production".to_owned(), |number| number.to_string());
		190	Thread {
		191	key: format!("{}/deploy/{}/{which}", wanted.repo_id, text("projectId").unwrap_or_default()),
		192	kind: Some(SubjectKind::Deploy),
		193	number: wanted.number,
		194	run_id: text("deploymentId"),
		195	link: text("path"),
		196	}
		197	}
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		198	// One run's deployment to one environment, waiting for review.
		199	"deployment.review_requested" => Thread {
		200	key: format!(
		201	"{}/review/{}/{}",
		202	wanted.repo_id,
		203	text("runId").unwrap_or_default(),
		204	text("environment").unwrap_or_default()
		205	),
		206	kind: Some(SubjectKind::Run),
		207	number: None,
		208	run_id: text("runId"),
		209	link: text("link"),
		210	},
Inbox: threads, reasons, subscriptions and watching1d ago		211	// A workflow on a branch: its next failure bumps the same thread.
		212	"workflow.completed" if subject.is_none() => {
		213	let branch = text("ref").unwrap_or_default();
		214	let branch = branch.strip_prefix("refs/heads/").unwrap_or(&branch).to_owned();
		215	let workflow = text("path").or_else(|| text("workflow")).unwrap_or_default();
		216	Thread {
		217	key: format!("{}/run/{workflow}@{branch}", wanted.repo_id),
		218	kind: Some(SubjectKind::Run),
		219	number: None,
		220	run_id: text("runId"),
		221	link: None,
		222	}
		223	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		224	// One alert, or one bypass request: its page is the link.
		225	kind if SECURITY_EVENTS.contains(&kind) => {
		226	let which = text("requestId").or_else(|| text("alertId")).unwrap_or_else(|| event.id.clone());
		227	Thread {
		228	key: format!("{}/security/{which}", wanted.repo_id),
		229	kind: None,
		230	number: None,
		231	run_id: None,
		232	link: text("link"),
		233	}
		234	}
Inbox: threads, reasons, subscriptions and watching1d ago		235	_ => match wanted.number {
		236	Some(number) => Thread {
		237	key: numbered_thread(&wanted.repo_id, number),
		238	kind: subject.and_then(|subject| subject.kind),
		239	number: Some(number),
		240	run_id: None,
		241	link: None,
		242	},
		243	None => Thread {
		244	key: format!("event/{}", event.id),
		245	kind: None,
		246	number: None,
		247	run_id: None,
		248	link: None,
		249	},
		250	},
		251	}
		252	}
		253
		254	/// The issue or pull request whose agent threads an event closes: what an
		255	/// agent was waiting on a person for is over.
		256	pub fn resolves(event: &Event) -> Option<String> {
		257	if !RESUMES.contains(&event.kind.as_str()) {
		258	return None;
		259	}
		260	let repo_id = event.data["repoId"].as_str().map(str::to_owned).or_else(|| event.repo_id.clone())?;
		261	let number = event.data["number"].as_u64().and_then(|n| u32::try_from(n).ok())?;
		262	Some(numbered_thread(&repo_id, number))
		263	}
		264
		265	/// Collects who is told, each once with the most specific reason, never
		266	/// the actor, never g1t, and never anyone ignoring the thread.
Inbox: the events service tells people what needs them as events arrive1d ago		267	struct Told<'a> {
		268	actor: &'a Actor,
Inbox: threads, reasons, subscriptions and watching1d ago		269	audience: &'a Audience,
Inbox: the events service tells people what needs them as events arrive1d ago		270	notices: Vec<Notice>,
		271	}
		272
		273	impl Told<'_> {
Inbox: threads, reasons, subscriptions and watching1d ago		274	/// `asked`: something asked of the person directly, told even when
		275	/// they unsubscribed from the thread.
		276	fn tell(&mut self, username: &str, reason: Reason, severity: Severity, title: &str, body: &str, asked: bool) {
Inbox: the events service tells people what needs them as events arrive1d ago		277	let username = username.trim().trim_start_matches('@').to_lowercase();
		278	if username.is_empty()
		279	|| is_g1t(&username)
		280	|| self.actor.is_named(&username)
Inbox: threads, reasons, subscriptions and watching1d ago		281	|| self.audience.ignores(&username)
		282	|| (!asked && self.audience.unsubscribed(&username))
Inbox: the events service tells people what needs them as events arrive1d ago		283	{
		284	return;
		285	}
Inbox: threads, reasons, subscriptions and watching1d ago		286	let notice = Notice {
Inbox: the events service tells people what needs them as events arrive1d ago		287	username,
		288	reason,
		289	severity,
		290	title: clip(title, MAX_TITLE),
		291	body: clip(body, MAX_BODY),
Inbox: threads, reasons, subscriptions and watching1d ago		292	};
		293	match self.notices.iter_mut().find(|told| told.username == notice.username) {
		294	Some(told) if notice.reason.rank() < told.reason.rank() => *told = notice,
		295	Some(_) => {}
		296	None => self.notices.push(notice),
		297	}
Inbox: the events service tells people what needs them as events arrive1d ago		298	}
		299
		300	/// A person known by id as well as name, such as an author.
Inbox: threads, reasons, subscriptions and watching1d ago		301	fn tell_person(&mut self, person: &Principal, reason: Reason, severity: Severity, title: &str, body: &str, asked: bool) {
Inbox: the events service tells people what needs them as events arrive1d ago		302	if is_g1t_id(&person.id) || self.actor.is(person) {
		303	return;
		304	}
Inbox: threads, reasons, subscriptions and watching1d ago		305	self.tell(&person.username, reason, severity, title, body, asked);
		306	}
		307
		308	/// Everyone subscribed to an issue or pull request: its owner and
		309	/// author, its assignees and reviewers, and whoever subscribed by
		310	/// commenting, being mentioned or by hand. `reason` overrides why
		311	/// each is told, as a state change does.
		312	fn tell_subscribed(&mut self, subject: &InboxSubject, reason: Option<Reason>, severity: Severity, title: &str, body: &str) {
		313	let why = |own: Reason| reason.unwrap_or(own);
		314	self.tell_person(subject.owner(), why(Reason::Author), severity, title, body, false);
		315	self.tell_person(&subject.author, why(Reason::Author), severity, title, body, false);
		316	for name in &subject.assignees {
		317	self.tell(name, why(Reason::Assign), severity, title, body, false);
		318	}
		319	for name in &subject.reviewers {
		320	self.tell(name, why(Reason::ReviewRequested), severity, title, body, false);
		321	}
		322	let subscribed: Vec<(String, Reason)> = self.audience.subscribed().collect();
		323	for (name, own) in subscribed {
		324	self.tell(&name, why(own), severity, title, body, false);
		325	}
Inbox: the events service tells people what needs them as events arrive1d ago		326	}
Inbox: threads, reasons, subscriptions and watching1d ago		327
		328	/// Everyone watching the repository for this kind of activity.
		329	fn tell_watchers(&mut self, kind: &str, severity: Severity, title: &str, body: &str) {
		330	let watching: Vec<String> = self.audience.watching(kind).collect();
		331	for name in watching {
		332	self.tell(&name, Reason::Subscribed, severity, title, body, false);
		333	}
		334	}
Inbox: the events service tells people what needs them as events arrive1d ago		335	}
		336
		337	fn clip(text: &str, max: usize) -> String {
		338	let text = text.trim();
		339	if text.chars().count() <= max {
		340	return text.to_owned();
		341	}
		342	let cut: String = text.chars().take(max - 1).collect();
		343	format!("{}…", cut.trim_end())
		344	}
		345
Inbox: threads, reasons, subscriptions and watching1d ago		346	/// The kind of activity a watcher chooses: `issues` or `pulls`.
		347	fn activity_of(subject: &InboxSubject) -> &'static str {
		348	match subject.kind {
		349	Some(SubjectKind::Pull) => "pulls",
		350	_ => "issues",
		351	}
		352	}
		353
		354	/// The names in an event's list field, such as the reviewers just asked.
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		355	/// The teams an event asked to review: each `workspace/slug` with the
		356	/// people it tells.
		357	fn teams_asked(data: &serde_json::Value) -> Vec<(String, Vec<String>)> {
		358	data["teams"]
		359	.as_array()
		360	.map(|teams| {
		361	teams
		362	.iter()
		363	.filter_map(|team| Some((team["team"].as_str()?.to_owned(), names(team, "notified"))))
		364	.collect()
		365	})
		366	.unwrap_or_default()
		367	}
		368
Inbox: threads, reasons, subscriptions and watching1d ago		369	fn names(data: &serde_json::Value, key: &str) -> Vec<String> {
		370	data[key]
		371	.as_array()
		372	.map(|names| names.iter().filter_map(|name| name.as_str().map(str::to_owned)).collect())
		373	.unwrap_or_default()
		374	}
		375
		376	/// Who is told of `event`, in `repo` (`owner/name`), given what it names
		377	/// and who follows it. `actor` is who caused it; outcomes nobody chose
		378	/// (checks, workflows, deployments, a review, an agent finishing or
		379	/// stopping) are told whoever caused them.
		380	pub fn notices(event: &Event, repo: &str, actor: &Actor, subject: Option<&InboxSubject>, audience: &Audience) -> Vec<Notice> {
Inbox: the events service tells people what needs them as events arrive1d ago		381	let nobody = Actor::default();
		382	let data = &event.data;
		383	// The issue or pull request, as titles name it: `acme/rocket#12`.
		384	let at = match data["number"].as_u64().or(data["pull"].as_u64()) {
		385	Some(number) if subject.is_some() => format!("{repo}#{number}"),
		386	_ => repo.to_owned(),
		387	};
		388	let outcome = matches!(
		389	event.kind.as_str(),
Inbox: threads, reasons, subscriptions and watching1d ago		390	"checks.completed"
		391	| "workflow.completed"
		392	| "review.completed"
		393	| "pull.ready"
		394	| "agent.asked"
		395	| "pull.stalled"
		396	| "deployment.failed"
		397	| "deployment.succeeded"
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		398	| "deployment.review_requested"
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		399	) || SECURITY_EVENTS.contains(&event.kind.as_str());
Inbox: the events service tells people what needs them as events arrive1d ago		400	let mut told = Told {
		401	actor: if outcome { &nobody } else { actor },
Inbox: threads, reasons, subscriptions and watching1d ago		402	audience,
Inbox: the events service tells people what needs them as events arrive1d ago		403	notices: Vec::new(),
		404	};
Inbox: threads, reasons, subscriptions and watching1d ago		405	// Who did it, as titles name them.
		406	let who = actor.name().unwrap_or("g1t");
Inbox: the events service tells people what needs them as events arrive1d ago		407
		408	match (event.kind.as_str(), subject) {
Inbox: threads, reasons, subscriptions and watching1d ago		409	("agent.asked" | "pull.stalled", Some(pull)) => {
		410	let (title, body) = if event.kind == "agent.asked" {
		411	(format!("An agent is waiting on {at}"), pull.title.clone())
		412	} else {
		413	let detail = data["detail"].as_str().map(str::trim).filter(|detail| !detail.is_empty());
		414	(format!("g1t stopped on {at} and needs you"), detail.unwrap_or(&pull.title).to_owned())
		415	};
		416	told.tell_person(pull.owner(), Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive1d ago		417	if let Some(issue) = &pull.issue {
Inbox: threads, reasons, subscriptions and watching1d ago		418	told.tell_person(issue.owner(), Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive1d ago		419	for name in &issue.assignees {
Inbox: threads, reasons, subscriptions and watching1d ago		420	told.tell(name, Reason::Agent, Severity::Warning, &title, &body, true);
Inbox: the events service tells people what needs them as events arrive1d ago		421	}
		422	}
		423	}
Inbox: threads, reasons, subscriptions and watching1d ago		424	("pull.review_requested", Some(pull)) => {
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		425	// Asked because the CODEOWNERS file says they own what changed.
		426	let owned = data["codeOwners"].as_bool() == Some(true);
		427	let title = if owned {
		428	format!("{at} changes files you own")
		429	} else {
		430	format!("{who} asked you to review {at}")
		431	};
Inbox: threads, reasons, subscriptions and watching1d ago		432	for name in names(data, "reviewers") {
		433	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, &pull.title, true);
		434	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		435	for (team, people) in teams_asked(data) {
		436	let title = if owned {
		437	format!("{at} changes files @{team} owns")
		438	} else {
		439	format!("{who} asked @{team} to review {at}")
		440	};
		441	for name in people {
		442	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, &pull.title, true);
		443	}
		444	}
Inbox: threads, reasons, subscriptions and watching1d ago		445	}
		446	("issue.assigned" | "pull.assigned", Some(on)) => {
		447	let title = format!("{who} assigned you to {at}");
		448	for name in names(data, "added") {
		449	told.tell(&name, Reason::Assign, Severity::Info, &title, &on.title, true);
		450	}
		451	}
		452	("issue.opened" | "pull.opened", Some(on)) => {
		453	let title = format!("{who} opened {at}");
		454	for name in &on.assignees {
		455	told.tell(name, Reason::Assign, Severity::Info, &format!("{who} assigned you to {at}"), &on.title, true);
		456	}
		457	for name in &on.reviewers {
		458	told.tell(name, Reason::ReviewRequested, Severity::Warning, &format!("{who} asked you to review {at}"), &on.title, true);
		459	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		460	for name in &on.mentions {
		461	told.tell(name, Reason::Mention, Severity::Info, &format!("{who} mentioned you on {at}"), &on.title, true);
		462	}
		463	for team in &on.team_mentions {
		464	let title = format!("{who} mentioned @{} on {at}", team.team);
		465	for name in &team.members {
		466	told.tell(name, Reason::TeamMention, Severity::Info, &title, &on.title, true);
		467	}
		468	}
Inbox: threads, reasons, subscriptions and watching1d ago		469	told.tell_watchers(activity_of(on), Severity::Info, &title, &on.title);
		470	}
Inbox: the events service tells people what needs them as events arrive1d ago		471	("checks.completed", Some(pull)) => {
		472	let title = match data["status"].as_str() {
Inbox: threads, reasons, subscriptions and watching1d ago		473	Some("errored") => format!("Checks could not run on {at}"),
		474	_ => format!("Checks failed on {at}"),
Inbox: the events service tells people what needs them as events arrive1d ago		475	};
Inbox: threads, reasons, subscriptions and watching1d ago		476	told.tell_person(pull.owner(), Reason::CiActivity, Severity::Error, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive1d ago		477	}
		478	("workflow.completed", subject) => {
		479	let workflow = data["workflow"].as_str().filter(|name| !name.is_empty()).unwrap_or("A workflow");
		480	match subject {
		481	Some(pull) => {
Inbox: threads, reasons, subscriptions and watching1d ago		482	let title = format!("{workflow} failed on {at}");
		483	told.tell_person(pull.owner(), Reason::CiActivity, Severity::Error, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive1d ago		484	}
		485	None => {
		486	// Not on a pull request: whoever pushed the commit it ran on.
		487	let branch = data["ref"].as_str().unwrap_or_default();
		488	let branch = branch.strip_prefix("refs/heads/").unwrap_or(branch);
		489	let title = format!("{workflow} failed on {branch} in {repo}");
		490	let body = format!("Run {} at {}", data["number"], short(data["sha"].as_str().unwrap_or_default()));
		491	if let Some(id) = &actor.id
		492	&& !is_g1t_id(id)
		493	&& let Some(name) = &actor.username
		494	{
Inbox: threads, reasons, subscriptions and watching1d ago		495	told.tell(name, Reason::CiActivity, Severity::Error, &title, &body, true);
		496	}
		497	}
		498	}
		499	}
		500	("deployment.failed" | "deployment.succeeded", subject) => {
		501	let failed = event.kind == "deployment.failed";
		502	let project = data["project"].as_str().filter(|name| !name.is_empty()).unwrap_or(repo);
		503	let what = match subject {
		504	Some(_) => format!("The preview of {at}"),
		505	None => format!("Production of {project}"),
		506	};
		507	let (title, severity) = if failed {
		508	(format!("{what} failed to deploy"), Severity::Error)
		509	} else {
		510	(format!("{what} is live"), Severity::Success)
		511	};
		512	let body = match (failed, data["error"].as_str().map(str::trim).filter(|error| !error.is_empty())) {
		513	(true, Some(error)) => error.to_owned(),
		514	_ => match subject {
		515	Some(pull) => pull.title.clone(),
		516	None => format!("Commit {}", short(data["commit"].as_str().unwrap_or_default())),
		517	},
		518	};
		519	// A success is news to whoever answers for it only after a failure.
		520	if failed || data["recovered"].as_bool() == Some(true) {
		521	let title = if failed { title.clone() } else { format!("{what} is live again") };
		522	match subject {
		523	Some(pull) => told.tell_person(pull.owner(), Reason::CiActivity, severity, &title, &body, true),
		524	None => {
		525	let pusher = actor
		526	.id
		527	.as_deref()
		528	.filter(|id| !is_g1t_id(id))
		529	.and(actor.username.as_deref())
		530	.or_else(|| data["triggeredBy"].as_str());
		531	if let Some(name) = pusher {
		532	told.tell(name, Reason::CiActivity, severity, &title, &body, true);
		533	}
Inbox: the events service tells people what needs them as events arrive1d ago		534	}
		535	}
		536	}
Inbox: threads, reasons, subscriptions and watching1d ago		537	told.tell_watchers("deployments", severity, &title, &body);
Inbox: the events service tells people what needs them as events arrive1d ago		538	}
		539	("review.completed", Some(pull)) => {
Inbox: threads, reasons, subscriptions and watching1d ago		540	let (title, severity) = match data["verdict"].as_str() {
		541	Some("approve") => (format!("g1t approved {at}"), Severity::Success),
		542	_ => (format!("g1t asked for changes on {at}"), Severity::Info),
Inbox: the events service tells people what needs them as events arrive1d ago		543	};
Inbox: threads, reasons, subscriptions and watching1d ago		544	told.tell_person(pull.owner(), Reason::Author, severity, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive1d ago		545	}
		546	("pull.ready", Some(pull)) => {
		547	// A change g1t made is ready: the agent's run is over.
		548	if let Some(owner) = pull.requested_by.as_ref().filter(|_| is_g1t_id(&pull.author.id) || is_g1t(&pull.author.username)) {
Inbox: threads, reasons, subscriptions and watching1d ago		549	let title = format!("g1t finished {at}");
		550	told.tell_person(owner, Reason::Author, Severity::Success, &title, &pull.title, true);
Inbox: the events service tells people what needs them as events arrive1d ago		551	}
		552	}
Inbox: threads, reasons, subscriptions and watching1d ago		553	("pull.merged" | "pull.closed" | "issue.closed" | "issue.reopened", Some(on)) => {
		554	let (verb, severity) = match event.kind.as_str() {
		555	"pull.merged" => ("merged", Severity::Success),
		556	"issue.reopened" => ("reopened", Severity::Info),
		557	_ => ("closed", Severity::Info),
		558	};
		559	let title = match (actor.name(), data["resolvedBy"].as_u64()) {
		560	(_, Some(pull)) if event.kind == "issue.closed" => format!("{at} was closed by #{pull}"),
		561	(Some(name), _) => format!("{name} {verb} {at}"),
		562	(None, _) => format!("{at} was {verb}"),
Inbox: the events service tells people what needs them as events arrive1d ago		563	};
Inbox: threads, reasons, subscriptions and watching1d ago		564	told.tell_subscribed(on, Some(Reason::StateChange), severity, &title, &on.title);
		565	told.tell_watchers(activity_of(on), severity, &title, &on.title);
Inbox: the events service tells people what needs them as events arrive1d ago		566	}
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		567	("deployment.review_requested", _) => {
		568	let environment = data["environment"].as_str().unwrap_or("an environment");
		569	let workflow = data["workflow"].as_str().unwrap_or("A workflow");
		570	let title = format!("{workflow} is waiting for your review to deploy to {environment} in {repo}");
		571	let body = data["title"].as_str().unwrap_or_default();
		572	// Those the actions service names: the environment's reviewers.
		573	for name in names(data, "notify") {
		574	told.tell(&name, Reason::ReviewRequested, Severity::Warning, &title, body, true);
		575	}
		576	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		577	(kind, None) if SECURITY_EVENTS.contains(&kind) => {
		578	let severity = match data["severity"].as_str() {
		579	_ if kind == "secret_scanning.bypass_requested" => Severity::Warning,
		580	_ if kind == "secret_scanning.bypass_reviewed" => Severity::Info,
		581	Some("critical" | "high") => Severity::Error,
		582	_ => Severity::Warning,
		583	};
		584	let what = data["title"].as_str().unwrap_or("A security alert");
		585	let title = match kind {
		586	"secret_scanning.bypass_requested" => format!("{who} asked to bypass push protection in {repo}"),
		587	"secret_scanning.bypass_reviewed" => {
		588	let verdict = data["state"].as_str().unwrap_or("reviewed");
		589	format!("Your request to bypass push protection in {repo} was {verdict}")
		590	}
		591	_ if data["pusher"].is_string() => format!("A push to {repo} was blocked: it adds a secret"),
		592	_ => format!("New security alert in {repo}"),
		593	};
		594	// Whoever pushed a blocked secret, and those the service names
		595	// (the workspace's owners, or whoever asked for a bypass).
		596	if let Some(pusher) = data["pusher"].as_str() {
		597	told.tell(pusher, Reason::SecurityAlert, Severity::Error, &title, what, true);
		598	}
		599	for name in names(data, "notify") {
		600	told.tell(&name, Reason::SecurityAlert, severity, &title, what, true);
		601	}
		602	// Watchers who chose security alerts, if they may see findings:
		603	// the service lists who may (`members`), as findings are never
		604	// shown to someone who cannot change the code.
		605	if !kind.starts_with("secret_scanning.bypass") {
		606	let members = names(data, "members");
		607	let watching: Vec<String> = told.audience.watching("security").collect();
		608	for name in watching.iter().filter(|name| members.iter().any(|member| member.eq_ignore_ascii_case(name))) {
		609	told.tell(name, Reason::SecurityAlert, severity, &title, what, false);
		610	}
		611	}
		612	}
Inbox: the events service tells people what needs them as events arrive1d ago		613	("comment.created", Some(on)) => {
		614	let Some(comment) = on.comment.as_ref().filter(|comment| !comment.event) else {
		615	return Vec::new();
		616	};
		617	// Whoever wrote it is the actor, whatever the event says.
		618	let writer = Actor {
		619	id: Some(comment.author.id.clone()),
		620	username: Some(comment.author.username.clone()),
		621	};
		622	told.actor = &writer;
		623	let who = &comment.author.username;
		624	let body = if comment.excerpt.is_empty() { &on.title } else { &comment.excerpt };
		625	for name in &comment.mentions {
Inbox: threads, reasons, subscriptions and watching1d ago		626	let title = format!("{who} mentioned you on {at}");
		627	told.tell(name, Reason::Mention, Severity::Info, &title, body, true);
Inbox: the events service tells people what needs them as events arrive1d ago		628	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		629	for team in &comment.team_mentions {
		630	let title = format!("{who} mentioned @{} on {at}", team.team);
		631	for name in &team.members {
		632	told.tell(name, Reason::TeamMention, Severity::Info, &title, body, true);
		633	}
		634	}
Inbox: threads, reasons, subscriptions and watching1d ago		635	let (severity, title) = match comment.verdict.as_deref() {
		636	Some("approve") => (Severity::Success, format!("{who} approved {at}")),
		637	Some("request_changes") => (Severity::Info, format!("{who} asked for changes on {at}")),
		638	_ => (Severity::Info, format!("{who} commented on {at}")),
Inbox: the events service tells people what needs them as events arrive1d ago		639	};
Inbox: threads, reasons, subscriptions and watching1d ago		640	// An approval or a request for changes is the owner's to hear
		641	// of whatever they chose; the rest, as they subscribed.
		642	if comment.verdict.is_some() {
		643	told.tell_person(on.owner(), Reason::Author, severity, &title, body, true);
		644	}
		645	told.tell_subscribed(on, None, severity, &title, body);
		646	told.tell_watchers(activity_of(on), severity, &title, body);
Inbox: the events service tells people what needs them as events arrive1d ago		647	return told.notices;
		648	}
		649	_ => {}
		650	}
		651	told.notices
		652	}
		653
Inbox: threads, reasons, subscriptions and watching1d ago		654	/// Who an event subscribes to its issue or pull request without asking,
		655	/// and why: whoever commented, whoever they mentioned, the people assigned
		656	/// and the reviewers asked. Never g1t.
		657	pub fn subscribes(event: &Event, subject: Option<&InboxSubject>) -> Vec<(String, Reason)> {
		658	let mut people: Vec<(String, Reason)> = Vec::new();
		659	let mut add = |name: &str, reason: Reason| {
		660	let name = name.trim().trim_start_matches('@').to_lowercase();
		661	if !name.is_empty() && !is_g1t(&name) && !people.iter().any(|(had, _)| *had == name) {
		662	people.push((name, reason));
		663	}
		664	};
		665	match event.kind.as_str() {
		666	"comment.created" => {
		667	if let Some(comment) = subject.and_then(|subject| subject.comment.as_ref()).filter(|comment| !comment.event) {
		668	if !is_g1t_id(&comment.author.id) {
		669	add(&comment.author.username, Reason::Comment);
		670	}
		671	for name in &comment.mentions {
		672	add(name, Reason::Mention);
		673	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		674	for team in &comment.team_mentions {
		675	for name in &team.members {
		676	add(name, Reason::TeamMention);
		677	}
		678	}
		679	}
		680	}
		681	"issue.opened" | "pull.opened" => {
		682	if let Some(on) = subject {
		683	for name in &on.mentions {
		684	add(name, Reason::Mention);
		685	}
		686	for team in &on.team_mentions {
		687	for name in &team.members {
		688	add(name, Reason::TeamMention);
		689	}
		690	}
Inbox: threads, reasons, subscriptions and watching1d ago		691	}
		692	}
		693	"issue.assigned" | "pull.assigned" => {
		694	for name in names(&event.data, "added") {
		695	add(&name, Reason::Assign);
		696	}
		697	}
		698	"pull.review_requested" => {
		699	for name in names(&event.data, "reviewers") {
		700	add(&name, Reason::ReviewRequested);
		701	}
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		702	for (_, people) in teams_asked(&event.data) {
		703	for name in people {
		704	add(&name, Reason::ReviewRequested);
		705	}
		706	}
Inbox: threads, reasons, subscriptions and watching1d ago		707	}
		708	_ => {}
		709	}
		710	people
		711	}
		712
Inbox: the events service tells people what needs them as events arrive1d ago		713	fn short(sha: &str) -> &str {
		714	sha.get(..7).unwrap_or(sha)
		715	}
		716
		717	/// Where an item is on g1t.sh.
Inbox: threads, reasons, subscriptions and watching1d ago		718	pub fn url(repo: Option<&str>, subject: Option<SubjectKind>, number: Option<u32>, run_id: Option<&str>, link: Option<&str>) -> String {
		719	if let Some(link) = link.filter(|link| link.starts_with('/')) {
		720	return link.to_owned();
		721	}
Inbox: the events service tells people what needs them as events arrive1d ago		722	let Some(repo) = repo else {
		723	return "/inbox".to_owned();
		724	};
		725	match (subject, number, run_id) {
		726	(Some(SubjectKind::Pull), Some(number), _) => format!("/{repo}/pull/{number}"),
		727	(Some(SubjectKind::Issue), Some(number), _) => format!("/{repo}/issues/{number}"),
		728	(Some(SubjectKind::Run), _, Some(run)) => format!("/{repo}/actions/runs/{run}"),
Inbox: threads, reasons, subscriptions and watching1d ago		729	(Some(SubjectKind::Deploy), Some(number), _) => format!("/{repo}/pull/{number}"),
Inbox: the events service tells people what needs them as events arrive1d ago		730	_ => format!("/{repo}"),
		731	}
		732	}
		733
		734	// --- Writing ---------------------------------------------------------------
		735
		736	/// The services the inbox reads from as events arrive.
		737	pub struct Sources<'a> {
		738	pub work: &'a Fetcher,
		739	pub repos: &'a Fetcher,
		740	pub identity: &'a Fetcher,
		741	}
		742
Inbox: threads, reasons, subscriptions and watching1d ago		743	/// One notice written, and whether it was news (not a redelivery): what
		744	/// may be emailed.
		745	struct Written {
		746	notice: Notice,
		747	repo_id: String,
		748	url: String,
		749	}
		750
Inbox: the events service tells people what needs them as events arrive1d ago		751	/// Writes the items a batch from the bus calls for. Never fails the batch:
		752	/// what cannot be worked out is logged and left.
		753	pub async fn deliver(db: &D1Database, sources: &Sources<'_>, events: &[Event]) {
Inbox: threads, reasons, subscriptions and watching1d ago		754	if let Err(error) = resolve(db, events).await {
		755	worker::console_error!("inbox: agent threads not closed: {error}");
		756	}
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		757	// A workspace's own notices, about no repository (workspace_notices).
		758	for event in events.iter().filter(|event| WORKSPACE_EVENTS.contains(&event.kind.as_str())) {
		759	if let Err(error) = deliver_workspace(db, event).await {
		760	worker::console_error!("inbox: {} {} not delivered: {error}", event.kind, event.id);
		761	}
		762	}
Inbox: the events service tells people what needs them as events arrive1d ago		763	let wanted: Vec<(&Event, Wanted)> = events
		764	.iter()
		765	.filter_map(|event| wants(event).map(|wanted| (event, wanted)))
		766	.collect();
Inbox: threads, reasons, subscriptions and watching1d ago		767	let created: Vec<&Event> = events.iter().filter(|event| event.kind == "repo.created").collect();
		768	if wanted.is_empty() && created.is_empty() {
Inbox: the events service tells people what needs them as events arrive1d ago		769	return;
		770	}
		771	// Everyone who caused one, named in one call.
		772	let ids: Vec<String> = wanted
		773	.iter()
Inbox: threads, reasons, subscriptions and watching1d ago		774	.map(|(event, _)| *event)
		775	.chain(created.iter().copied())
		776	.filter_map(|event| event.actor.clone())
Inbox: the events service tells people what needs them as events arrive1d ago		777	.filter(|id| !is_g1t_id(id))
		778	.collect::<HashSet<_>>()
		779	.into_iter()
		780	.collect();
		781	let names: HashMap<String, String> = if ids.is_empty() {
		782	HashMap::new()
		783	} else {
		784	g1t_kit::call(sources.identity, "usernames", &UsernamesArgs { ids })
		785	.await
		786	.unwrap_or_else(|error| {
		787	worker::console_error!("inbox: could not name who acted: {error}");
		788	HashMap::new()
		789	})
		790	};
Inbox: threads, reasons, subscriptions and watching1d ago		791	for event in created {
		792	if let Err(error) = subscriptions::watch_created(db, event, &names).await {
		793	worker::console_error!("inbox: {} {} not watched: {error}", event.kind, event.id);
		794	}
		795	}
Inbox: the events service tells people what needs them as events arrive1d ago		796	let mut paths: HashMap<String, Option<RepoPath>> = HashMap::new();
Inbox: threads, reasons, subscriptions and watching1d ago		797	let mut watchers: HashMap<String, Vec<subscriptions::Watcher>> = HashMap::new();
		798	let mut written: Vec<Written> = Vec::new();
Inbox: the events service tells people what needs them as events arrive1d ago		799	for (event, wanted) in wanted {
Inbox: threads, reasons, subscriptions and watching1d ago		800	match deliver_one(db, sources, &names, &mut paths, &mut watchers, event, wanted).await {
		801	Ok(mut news) => written.append(&mut news),
		802	Err(error) => worker::console_error!("inbox: {} {} not delivered: {error}", event.kind, event.id),
		803	}
		804	}
		805	if let Err(error) = email(db, sources.identity, written).await {
		806	worker::console_error!("inbox: emails not sent: {error}");
		807	}
		808	}
		809
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		810	/// Events about a workspace rather than a repository, each naming who to
		811	/// tell (`notify`), what to say (`title`, `body`) and where it is (`link`):
		812	/// identity's personal access token approvals.
		813	///
		814	/// | Event | Who | Reason | Severity |
		815	/// | --- | --- | --- | --- |
		816	/// | `token.approval_requested` | the workspace's owners | review_requested | warning |
		817	/// | `token.approval_reviewed` | the token's owner | author | info |
		818	pub const WORKSPACE_EVENTS: [&str; 2] = ["token.approval_requested", "token.approval_reviewed"];
		819
		820	/// The notices a workspace event calls for, and the thread they go to.
		821	pub fn workspace_notices(event: &Event, actor: Option<&str>) -> (String, Vec<Notice>) {
		822	let data = &event.data;
		823	let text = |key: &str| data[key].as_str().unwrap_or_default().to_owned();
		824	let (reason, severity) = match event.kind.as_str() {
		825	"token.approval_requested" => (Reason::ReviewRequested, Severity::Warning),
		826	_ => (Reason::Author, Severity::Info),
		827	};
		828	let thread = format!("workspace:{}/token/{}", text("workspace"), text("tokenId"));
		829	let notices = names(data, "notify")
		830	.into_iter()
		831	.map(|name| name.to_lowercase())
		832	.filter(|name| actor.is_none_or(|actor| !actor.eq_ignore_ascii_case(name)) && !is_g1t(name))
		833	.collect::<HashSet<_>>()
		834	.into_iter()
		835	.map(|username| Notice { username, reason, severity, title: text("title"), body: text("body") })
		836	.collect();
		837	(thread, notices)
		838	}
		839
		840	/// Writes a workspace event's notices: a thread each, with no repository.
		841	async fn deliver_workspace(db: &D1Database, event: &Event) -> Result<()> {
		842	let (thread, told) = workspace_notices(event, None);
		843	if told.is_empty() {
		844	return Ok(());
		845	}
		846	let now = now_ms();
		847	let workspace = event.data["workspace"].as_str().unwrap_or_default().to_lowercase();
		848	let link = event.data["link"].as_str().filter(|link| link.starts_with('/'));
		849	let mut statements = Vec::new();
		850	for notice in &told {
		851	let username = notice.username.as_str();
		852	statements.push(db.prepare(BUMP).bind(&[
		853	new_id("ntf", now).into(),
		854	username.into(),
		855	thread.as_str().into(),
		856	event.id.as_str().into(),
		857	event.kind.as_str().into(),
		858	notice.reason.as_str().into(),
		859	notice.severity.as_str().into(),
		860	notice.title.as_str().into(),
		861	notice.body.as_str().into(),
		862	workspace.as_str().into(),
		863	JsValue::NULL,
		864	JsValue::NULL,
		865	JsValue::NULL,
		866	JsValue::NULL,
		867	JsValue::NULL,
		868	link.map_or(JsValue::NULL, JsValue::from),
		869	JsValue::NULL,
		870	event.time.as_str().into(),
		871	new_id("ntf", now).into(),
		872	])?);
		873	statements.push(
		874	db.prepare(
		875	"INSERT OR IGNORE INTO inbox_activity (id, item_id, username, event_id, event, reason, severity, title, body, actor, created_at)
		876	SELECT ?1, id, ?2, ?4, ?5, ?6, ?7, ?8, ?9, NULL, ?10 FROM inbox_items WHERE username = ?2 AND thread = ?3",
		877	)
		878	.bind(&[
		879	new_id("ntf", now).into(),
		880	username.into(),
		881	thread.as_str().into(),
		882	event.id.as_str().into(),
		883	event.kind.as_str().into(),
		884	notice.reason.as_str().into(),
		885	notice.severity.as_str().into(),
		886	notice.title.as_str().into(),
		887	notice.body.as_str().into(),
		888	event.time.as_str().into(),
		889	])?,
		890	);
		891	}
		892	db.batch(statements).await?;
		893	Ok(())
		894	}
		895
Inbox: threads, reasons, subscriptions and watching1d ago		896	/// Closes what an agent was waiting on a person for once it is over.
		897	async fn resolve(db: &D1Database, events: &[Event]) -> Result<()> {
		898	let now = rfc3339(now_ms());
		899	let mut statements = Vec::new();
		900	for thread in events.iter().filter_map(resolves) {
		901	statements.push(
		902	db.prepare(
		903	"UPDATE inbox_items SET done_at = ?1, read_at = COALESCE(read_at, ?1)
		904	WHERE thread = ?2 AND reason = 'agent' AND done_at IS NULL",
		905	)
		906	.bind(&[now.as_str().into(), thread.into()])?,
		907	);
		908	}
		909	// Reviews no longer asked for are no longer waiting.
		910	for event in events.iter().filter(|event| event.kind == "pull.review_request_removed") {
		911	let (Some(repo_id), Some(number)) = (
		912	event.data["repoId"].as_str().map(str::to_owned).or_else(|| event.repo_id.clone()),
		913	event.data["number"].as_u64(),
		914	) else {
		915	continue;
		916	};
		917	for name in names(&event.data, "reviewers") {
		918	statements.push(
		919	db.prepare(
		920	"UPDATE inbox_items SET done_at = ?1, read_at = COALESCE(read_at, ?1)
		921	WHERE thread = ?2 AND username = ?3 AND reason = 'review_requested' AND done_at IS NULL",
		922	)
		923	.bind(&[
		924	now.as_str().into(),
		925	format!("{repo_id}#{number}").into(),
		926	name.to_lowercase().into(),
		927	])?,
		928	);
Inbox: the events service tells people what needs them as events arrive1d ago		929	}
		930	}
Inbox: threads, reasons, subscriptions and watching1d ago		931	if !statements.is_empty() {
		932	db.batch(statements).await?;
		933	}
		934	Ok(())
Inbox: the events service tells people what needs them as events arrive1d ago		935	}
		936
		937	async fn deliver_one(
		938	db: &D1Database,
		939	sources: &Sources<'_>,
		940	names: &HashMap<String, String>,
		941	paths: &mut HashMap<String, Option<RepoPath>>,
Inbox: threads, reasons, subscriptions and watching1d ago		942	watchers: &mut HashMap<String, Vec<subscriptions::Watcher>>,
Inbox: the events service tells people what needs them as events arrive1d ago		943	event: &Event,
		944	wanted: Wanted,
Inbox: threads, reasons, subscriptions and watching1d ago		945	) -> Result<Vec<Written>> {
Inbox: the events service tells people what needs them as events arrive1d ago		946	if !paths.contains_key(&wanted.repo_id) {
		947	let path: Option<RepoPath> = g1t_kit::call(
		948	sources.repos,
		949	"path_by_id",
		950	&PathByIdArgs {
		951	id: wanted.repo_id.clone(),
		952	},
		953	)
		954	.await?;
		955	paths.insert(wanted.repo_id.clone(), path);
		956	}
		957	// A repository that is gone tells nobody.
		958	let Some(path) = paths.get(&wanted.repo_id).cloned().flatten() else {
Inbox: threads, reasons, subscriptions and watching1d ago		959	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive1d ago		960	};
		961	let subject: Option<InboxSubject> = match wanted.number {
		962	Some(number) => {
		963	let found: Option<InboxSubject> = g1t_kit::call(
		964	sources.work,
		965	"inbox_subject",
		966	&InboxSubjectArgs {
		967	repo_id: wanted.repo_id.clone(),
		968	number,
		969	comment_id: wanted.comment_id.clone(),
		970	},
		971	)
		972	.await?;
		973	if found.is_none() {
Inbox: threads, reasons, subscriptions and watching1d ago		974	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive1d ago		975	}
		976	found
		977	}
		978	None => None,
		979	};
		980	let actor = Actor {
		981	id: event.actor.clone(),
		982	username: match event.actor.as_deref() {
		983	Some(id) if is_g1t_id(id) => Some(system::USERNAME.to_owned()),
		984	Some(id) => names.get(id).map(|name| name.to_lowercase()),
		985	None => None,
		986	},
		987	};
Inbox: threads, reasons, subscriptions and watching1d ago		988	let thread = thread_of(event, &wanted, subject.as_ref());
		989	if !watchers.contains_key(&wanted.repo_id) {
		990	watchers.insert(wanted.repo_id.clone(), subscriptions::watchers(db, &wanted.repo_id).await?);
		991	}
		992	let audience = Audience {
		993	subscriptions: match thread.kind {
		994	Some(SubjectKind::Issue | SubjectKind::Pull) => subscriptions::of_thread(db, &thread.key).await?,
		995	_ => Vec::new(),
		996	},
		997	watchers: watchers.get(&wanted.repo_id).cloned().unwrap_or_default(),
		998	};
Inbox: the events service tells people what needs them as events arrive1d ago		999	let repo = format!("{}/{}", path.namespace, path.name).to_lowercase();
Inbox: threads, reasons, subscriptions and watching1d ago		1000	let told = notices(event, &repo, &actor, subject.as_ref(), &audience);
		1001	let mut statements = subscriptions::auto_subscribe(db, &thread.key, &wanted.repo_id, &subscribes(event, subject.as_ref()), &event.time)?;
Inbox: the events service tells people what needs them as events arrive1d ago		1002	if told.is_empty() {
Inbox: threads, reasons, subscriptions and watching1d ago		1003	if !statements.is_empty() {
		1004	db.batch(statements).await?;
		1005	}
		1006	return Ok(Vec::new());
Inbox: the events service tells people what needs them as events arrive1d ago		1007	}
		1008	let now = now_ms();
Inbox: threads, reasons, subscriptions and watching1d ago		1009	let link = thread.link.as_deref();
		1010	let item_url = url(Some(&repo), thread.kind, thread.number, thread.run_id.as_deref(), link);
		1011	// Three statements a notice: its thread brought up (unless this event
		1012	// was told before), a line of history, and the history kept short.
		1013	let first = statements.len();
		1014	for notice in &told {
		1015	let username = notice.username.as_str();
		1016	let values: Vec<JsValue> = vec![
		1017	new_id("ntf", now).into(),
		1018	username.into(),
		1019	thread.key.as_str().into(),
		1020	event.id.as_str().into(),
		1021	event.kind.as_str().into(),
		1022	notice.reason.as_str().into(),
		1023	notice.severity.as_str().into(),
		1024	notice.title.as_str().into(),
		1025	notice.body.as_str().into(),
		1026	path.namespace.to_lowercase().into(),
		1027	wanted.repo_id.as_str().into(),
		1028	repo.as_str().into(),
		1029	thread.kind.map_or(JsValue::NULL, |kind| kind.as_str().into()),
		1030	thread.number.map_or(JsValue::NULL, JsValue::from),
		1031	thread.run_id.as_deref().map_or(JsValue::NULL, JsValue::from),
		1032	link.map_or(JsValue::NULL, JsValue::from),
		1033	actor.username.as_deref().map_or(JsValue::NULL, JsValue::from),
		1034	event.time.as_str().into(),
		1035	// Same prefix as item ids, so old and new sort by time together.
		1036	new_id("ntf", now).into(),
		1037	];
		1038	statements.push(db.prepare(BUMP).bind(&values)?);
Inbox: the events service tells people what needs them as events arrive1d ago		1039	statements.push(
		1040	db.prepare(
Inbox: threads, reasons, subscriptions and watching1d ago		1041	"INSERT OR IGNORE INTO inbox_activity (id, item_id, username, event_id, event, reason, severity, title, body, actor, created_at)
		1042	SELECT ?1, id, ?2, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11 FROM inbox_items WHERE username = ?2 AND thread = ?3
		1043	RETURNING username",
Inbox: the events service tells people what needs them as events arrive1d ago		1044	)
		1045	.bind(&[
		1046	new_id("ntf", now).into(),
Inbox: threads, reasons, subscriptions and watching1d ago		1047	username.into(),
		1048	thread.key.as_str().into(),
Inbox: the events service tells people what needs them as events arrive1d ago		1049	event.id.as_str().into(),
Inbox: threads, reasons, subscriptions and watching1d ago		1050	event.kind.as_str().into(),
		1051	notice.reason.as_str().into(),
Inbox: the events service tells people what needs them as events arrive1d ago		1052	notice.severity.as_str().into(),
		1053	notice.title.as_str().into(),
		1054	notice.body.as_str().into(),
		1055	actor.username.as_deref().map_or(JsValue::NULL, JsValue::from),
		1056	event.time.as_str().into(),
		1057	])?,
		1058	);
Inbox: threads, reasons, subscriptions and watching1d ago		1059	statements.push(
		1060	db.prepare(
		1061	"DELETE FROM inbox_activity
		1062	WHERE item_id = (SELECT id FROM inbox_items WHERE username = ?1 AND thread = ?2)
		1063	AND id NOT IN (
		1064	SELECT a.id FROM inbox_activity a
		1065	WHERE a.item_id = (SELECT id FROM inbox_items WHERE username = ?1 AND thread = ?2)
		1066	ORDER BY a.id DESC LIMIT ?3)",
		1067	)
		1068	.bind(&[username.into(), thread.key.as_str().into(), MAX_ACTIVITY.into()])?,
		1069	);
		1070	}
		1071	let results = db.batch(statements).await?;
		1072	#[derive(Deserialize)]
		1073	struct Told {
		1074	username: String,
Inbox: the events service tells people what needs them as events arrive1d ago		1075	}
Inbox: threads, reasons, subscriptions and watching1d ago		1076	// A line of history written means the event is news to that person.
		1077	let mut news = HashSet::new();
		1078	for (at, _) in told.iter().enumerate() {
		1079	if let Some(result) = results.get(first + at * 3 + 1)
		1080	&& let Ok(rows) = result.results::<Told>()
		1081	{
		1082	news.extend(rows.into_iter().map(|row| row.username));
		1083	}
		1084	}
		1085	Ok(told
		1086	.into_iter()
		1087	.filter(|notice| news.contains(&notice.username))
		1088	.map(|notice| Written {
		1089	notice,
		1090	repo_id: wanted.repo_id.clone(),
		1091	url: item_url.clone(),
		1092	})
		1093	.collect())
		1094	}
		1095
		1096	/// Brings a person's thread up with new activity, or starts it. `?1` id,
		1097	/// `?2` username, `?3` thread, `?4` event id, `?5` event type, `?6` reason,
		1098	/// `?7` severity, `?8` title, `?9` body, `?10` workspace, `?11` repo id,
		1099	/// `?12` repo, `?13` subject, `?14` number, `?15` run id, `?16` link, `?17`
		1100	/// actor, `?18` time, `?19` the time-sortable id lists order by. Nothing
		1101	/// happens when the person was already told of this event. While the
		1102	/// thread is unread its most urgent severity is kept; done or not, it
		1103	/// comes back to the inbox. A snooze stands.
		1104	const BUMP: &str = "INSERT INTO inbox_items (id, username, thread, event_id, event, reason, severity, title, body,
		1105	workspace, repo_id, repo, subject, number, run_id, link, actor, created_at, updated_at, bumped, activity)
		1106	SELECT ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?18, ?19, 1
		1107	WHERE NOT EXISTS (SELECT 1 FROM inbox_activity WHERE event_id = ?4 AND username = ?2)
		1108	ON CONFLICT (username, thread) DO UPDATE SET
		1109	event_id = excluded.event_id,
		1110	event = excluded.event,
		1111	reason = excluded.reason,
		1112	severity = CASE
		1113	WHEN inbox_items.read_at IS NULL AND inbox_items.done_at IS NULL
		1114	AND (CASE inbox_items.severity WHEN 'warning' THEN 0 WHEN 'error' THEN 1 WHEN 'success' THEN 2 ELSE 3 END)
		1115	< (CASE excluded.severity WHEN 'warning' THEN 0 WHEN 'error' THEN 1 WHEN 'success' THEN 2 ELSE 3 END)
		1116	THEN inbox_items.severity ELSE excluded.severity END,
		1117	title = excluded.title,
		1118	body = excluded.body,
		1119	workspace = excluded.workspace,
		1120	repo = excluded.repo,
		1121	subject = COALESCE(excluded.subject, inbox_items.subject),
		1122	run_id = COALESCE(excluded.run_id, inbox_items.run_id),
		1123	link = COALESCE(excluded.link, inbox_items.link),
		1124	actor = excluded.actor,
		1125	updated_at = excluded.updated_at,
		1126	bumped = excluded.bumped,
		1127	activity = inbox_items.activity + 1,
		1128	read_at = NULL,
		1129	done_at = NULL";
		1130
		1131	/// Emails what was news to people who asked to be emailed for its reason.
		1132	/// Identity sends each, only to a confirmed address and only if the person
		1133	/// can still read the repository.
		1134	async fn email(db: &D1Database, identity: &Fetcher, written: Vec<Written>) -> Result<()> {
		1135	if written.is_empty() {
		1136	return Ok(());
		1137	}
		1138	let people: Vec<String> = written
		1139	.iter()
		1140	.map(|item| item.notice.username.clone())
		1141	.collect::<HashSet<_>>()
		1142	.into_iter()
		1143	.collect();
		1144	let settings = subscriptions::settings_of(db, &people).await?;
		1145	for item in written {
		1146	let wants = settings.get(&item.notice.username).map_or(&DEFAULT_EMAIL[..], |settings| &settings.email[..]);
		1147	if !wants.contains(&item.notice.reason) {
		1148	continue;
		1149	}
		1150	let sent: Result<bool> = g1t_kit::call(
		1151	identity,
		1152	"notify_by_email",
		1153	&NotifyByEmailArgs {
		1154	username: item.notice.username.clone(),
		1155	repo_id: item.repo_id.clone(),
		1156	subject: item.notice.title.clone(),
		1157	intro: item.notice.body.clone(),
		1158	quote: None,
		1159	path: item.url.clone(),
		1160	reason: item.notice.reason,
		1161	},
		1162	)
		1163	.await;
		1164	if let Err(error) = sent {
		1165	worker::console_error!("inbox: email to {} not sent: {error}", item.notice.username);
		1166	}
		1167	}
Inbox: the events service tells people what needs them as events arrive1d ago		1168	Ok(())
		1169	}
		1170
		1171	// --- Reading and changing ----------------------------------------------------
		1172
		1173	#[derive(Deserialize)]
Inbox: threads, reasons, subscriptions and watching1d ago		1174	pub(crate) struct Row {
		1175	pub(crate) id: String,
Inbox: the events service tells people what needs them as events arrive1d ago		1176	reason: String,
		1177	severity: String,
		1178	title: String,
		1179	body: String,
Inbox: threads, reasons, subscriptions and watching1d ago		1180	event: Option<String>,
Inbox: the events service tells people what needs them as events arrive1d ago		1181	workspace: Option<String>,
Inbox: threads, reasons, subscriptions and watching1d ago		1182	pub(crate) repo_id: Option<String>,
Inbox: the events service tells people what needs them as events arrive1d ago		1183	repo: Option<String>,
		1184	subject: Option<String>,
		1185	number: Option<f64>,
		1186	run_id: Option<String>,
Inbox: threads, reasons, subscriptions and watching1d ago		1187	link: Option<String>,
Inbox: the events service tells people what needs them as events arrive1d ago		1188	actor: Option<String>,
Inbox: threads, reasons, subscriptions and watching1d ago		1189	activity: Option<f64>,
Inbox: the events service tells people what needs them as events arrive1d ago		1190	created_at: String,
Inbox: threads, reasons, subscriptions and watching1d ago		1191	updated_at: Option<String>,
Inbox: the events service tells people what needs them as events arrive1d ago		1192	read_at: Option<String>,
		1193	done_at: Option<String>,
		1194	saved: f64,
		1195	snoozed_until: Option<String>,
Inbox: threads, reasons, subscriptions and watching1d ago		1196	bumped: Option<String>,
Inbox: the events service tells people what needs them as events arrive1d ago		1197	}
		1198
		1199	impl Row {
Inbox: threads, reasons, subscriptions and watching1d ago		1200	pub(crate) fn into_item(self) -> InboxItem {
Inbox: the events service tells people what needs them as events arrive1d ago		1201	let subject = self.subject.as_deref().and_then(SubjectKind::parse);
		1202	let number = self.number.map(|n| n as u32);
		1203	InboxItem {
Inbox: threads, reasons, subscriptions and watching1d ago		1204	url: url(self.repo.as_deref(), subject, number, self.run_id.as_deref(), self.link.as_deref()),
Inbox: the events service tells people what needs them as events arrive1d ago		1205	id: self.id,
Inbox: threads, reasons, subscriptions and watching1d ago		1206	reason: Reason::parse(&self.reason).unwrap_or(Reason::Subscribed),
Inbox: the events service tells people what needs them as events arrive1d ago		1207	severity: Severity::parse(&self.severity).unwrap_or(Severity::Info),
		1208	title: self.title,
		1209	body: self.body,
Inbox: threads, reasons, subscriptions and watching1d ago		1210	event: self.event,
Inbox: the events service tells people what needs them as events arrive1d ago		1211	repo: self.repo,
		1212	workspace: self.workspace,
		1213	subject,
		1214	number,
		1215	actor: self.actor,
Inbox: threads, reasons, subscriptions and watching1d ago		1216	count: self.activity.map_or(1, |n| n as u32),
		1217	updated_at: self.updated_at.unwrap_or_else(|| self.created_at.clone()),
Inbox: the events service tells people what needs them as events arrive1d ago		1218	created_at: self.created_at,
		1219	read_at: self.read_at,
		1220	done_at: self.done_at,
		1221	saved: self.saved != 0.0,
		1222	snoozed_until: self.snoozed_until,
		1223	}
		1224	}
		1225	}
		1226
Inbox: threads, reasons, subscriptions and watching1d ago		1227	pub(crate) const COLUMNS: &str = "id, reason, severity, title, body, event, workspace, repo_id, repo, subject, number, run_id,
		1228	link, actor, activity, created_at, updated_at, read_at, done_at, saved, snoozed_until, bumped";
Inbox: the events service tells people what needs them as events arrive1d ago		1229
		1230	/// The conditions that pick a view's items, after `username = ?1`; `?2` is now.
		1231	fn view_filter(view: InboxView) -> &'static str {
		1232	match view {
		1233	InboxView::Inbox => "done_at IS NULL AND (snoozed_until IS NULL OR snoozed_until <= ?2)",
		1234	InboxView::Saved => "saved = 1",
		1235	InboxView::Done => "done_at IS NOT NULL",
		1236	}
		1237	}
		1238
		1239	/// Whether a list ranks unread warnings first: the inbox itself, unfiltered.
		1240	fn ranked(a: &ListInboxArgs) -> bool {
Inbox: threads, reasons, subscriptions and watching1d ago		1241	a.view == InboxView::Inbox
		1242	&& a.severity.is_none()
		1243	&& a.reason.is_none()
		1244	&& !a.participating
		1245	&& a.repo_id.is_none()
		1246	&& !a.unread
		1247	&& a.since.is_none()
		1248	&& a.updated_before.is_none()
Inbox: the events service tells people what needs them as events arrive1d ago		1249	}
		1250
Inbox: threads, reasons, subscriptions and watching1d ago		1251	/// The conditions a list's filters add, and the values they bind, numbered
		1252	/// after the `bound` values already given.
		1253	fn filters(a: &ListInboxArgs, bound: usize) -> (Vec<String>, Vec<String>) {
		1254	let mut conditions = Vec::new();
		1255	let mut values: Vec<String> = Vec::new();
		1256	let mut bind = |value: &str, condition: &str| {
		1257	values.push(value.to_owned());
		1258	conditions.push(condition.replace('?', &format!("?{}", bound + values.len())));
		1259	};
		1260	if let Some(severity) = a.severity {
		1261	bind(severity.as_str(), "severity = ?");
		1262	}
		1263	if let Some(reason) = a.reason {
		1264	bind(reason.as_str(), "reason = ?");
		1265	}
		1266	if let Some(repo_id) = &a.repo_id {
		1267	bind(repo_id, "repo_id = ?");
		1268	}
		1269	if let Some(since) = &a.since {
		1270	bind(since.trim(), "COALESCE(updated_at, created_at) >= ?");
		1271	}
		1272	if let Some(before) = &a.updated_before {
		1273	bind(before.trim(), "COALESCE(updated_at, created_at) < ?");
		1274	}
		1275	if a.participating {
		1276	conditions.push("reason NOT IN ('manual', 'subscribed')".to_owned());
		1277	}
		1278	if a.unread {
		1279	conditions.push("read_at IS NULL".to_owned());
		1280	}
		1281	(conditions, values)
		1282	}
		1283
Inbox: the events service tells people what needs them as events arrive1d ago		1284	pub async fn list(db: &D1Database, repos: &Fetcher, a: ListInboxArgs) -> Result<InboxPage> {
		1285	let Some(viewer) = &a.viewer else {
		1286	return Ok(InboxPage::default());
		1287	};
		1288	let username = viewer.username.to_lowercase();
		1289	let now = rfc3339(now_ms());
		1290	let limit = a.limit.unwrap_or(DEFAULT_INBOX_PAGE).clamp(1, MAX_INBOX_PAGE);
		1291	let mut values: Vec<JsValue> = vec![username.as_str().into(), now.as_str().into()];
Inbox: threads, reasons, subscriptions and watching1d ago		1292	let mut conditions = vec!["username = ?1".to_owned(), view_filter(a.view).to_owned()];
		1293	let (filtered, bound) = filters(&a, values.len());
		1294	conditions.extend(filtered);
		1295	values.extend(bound.iter().map(|value| JsValue::from(value.as_str())));
Inbox: the events service tells people what needs them as events arrive1d ago		1296	let ranked = ranked(&a);
		1297	// Unread warnings lead the first page, and are left out of the rest.
		1298	let leading = "severity = 'warning' AND read_at IS NULL";
		1299	let mut rest = conditions.clone();
Inbox: threads, reasons, subscriptions and watching1d ago		1300	let mut rest_values = values.clone();
Inbox: the events service tells people what needs them as events arrive1d ago		1301	if ranked {
		1302	rest.push(format!("NOT ({leading})"));
		1303	}
		1304	if let Some(before) = &a.before {
Inbox: threads, reasons, subscriptions and watching1d ago		1305	rest_values.push(before.as_str().into());
		1306	rest.push(format!("bumped < ?{}", rest_values.len()));
Inbox: the events service tells people what needs them as events arrive1d ago		1307	}
Inbox: threads, reasons, subscriptions and watching1d ago		1308	rest_values.push((limit + 1).into());
		1309	let order = if a.view == InboxView::Done { "done_at DESC, bumped DESC" } else { "bumped DESC" };
Inbox: the events service tells people what needs them as events arrive1d ago		1310	let mut statements = vec![
		1311	db.prepare(format!(
		1312	"SELECT {COLUMNS} FROM inbox_items WHERE {} ORDER BY {order} LIMIT ?{}",
		1313	rest.join(" AND "),
Inbox: threads, reasons, subscriptions and watching1d ago		1314	rest_values.len()
Inbox: the events service tells people what needs them as events arrive1d ago		1315	))
Inbox: threads, reasons, subscriptions and watching1d ago		1316	.bind(&rest_values)?,
Inbox: the events service tells people what needs them as events arrive1d ago		1317	];
		1318	if ranked && a.before.is_none() {
		1319	statements.push(
		1320	db.prepare(format!(
Inbox: threads, reasons, subscriptions and watching1d ago		1321	"SELECT {COLUMNS} FROM inbox_items WHERE {} AND {leading} ORDER BY bumped DESC LIMIT ?3",
		1322	conditions.join(" AND ")
Inbox: the events service tells people what needs them as events arrive1d ago		1323	))
		1324	.bind(&[username.as_str().into(), now.as_str().into(), MAX_RANKED.into()])?,
		1325	);
		1326	}
		1327	let results = db.batch(statements).await?;
		1328	let mut rows = results.first().map(|result| result.results::<Row>()).transpose()?.unwrap_or_default();
		1329	let next = if rows.len() > limit as usize {
		1330	rows.truncate(limit as usize);
Inbox: threads, reasons, subscriptions and watching1d ago		1331	rows.last().map(|row| row.bumped.clone().unwrap_or_else(|| row.id.clone()))
Inbox: the events service tells people what needs them as events arrive1d ago		1332	} else {
		1333	None
		1334	};
		1335	let mut items: Vec<Row> = results.get(1).map(|result| result.results::<Row>()).transpose()?.unwrap_or_default();
		1336	items.extend(rows);
Inbox: threads, reasons, subscriptions and watching1d ago		1337	let items = readable_only(db, repos, &a.viewer, &username, items).await?;
		1338	Ok(InboxPage {
		1339	items: items.into_iter().map(Row::into_item).collect(),
		1340	next,
		1341	})
		1342	}
Inbox: the events service tells people what needs them as events arrive1d ago		1343
Inbox: threads, reasons, subscriptions and watching1d ago		1344	/// Rows about repositories the viewer can still read; the rest are
		1345	/// removed from their inbox as they are found.
		1346	pub(crate) async fn readable_only(db: &D1Database, repos: &Fetcher, viewer: &g1t_contracts::Viewer, username: &str, mut rows: Vec<Row>) -> Result<Vec<Row>> {
		1347	let ids: Vec<String> = rows
Inbox: the events service tells people what needs them as events arrive1d ago		1348	.iter()
		1349	.filter_map(|row| row.repo_id.clone())
		1350	.collect::<HashSet<_>>()
		1351	.into_iter()
		1352	.collect();
Inbox: threads, reasons, subscriptions and watching1d ago		1353	if ids.is_empty() {
		1354	return Ok(rows);
		1355	}
		1356	let readable: Vec<Repo> = g1t_kit::call(
		1357	repos,
		1358	"readable",
		1359	&ReadableArgs {
		1360	ids: ids.clone(),
		1361	viewer: viewer.clone(),
		1362	},
		1363	)
		1364	.await?;
		1365	let readable: HashSet<String> = readable.into_iter().map(|repo| repo.id).collect();
		1366	let gone: Vec<String> = ids.into_iter().filter(|id| !readable.contains(id)).collect();
		1367	if !gone.is_empty() {
		1368	forget(db, username, &gone).await?;
		1369	rows.retain(|row| row.repo_id.as_ref().is_none_or(|id| !gone.contains(id)));
Inbox: the events service tells people what needs them as events arrive1d ago		1370	}
Inbox: threads, reasons, subscriptions and watching1d ago		1371	Ok(rows)
Inbox: the events service tells people what needs them as events arrive1d ago		1372	}
		1373
		1374	/// Removes a person's items about repositories they cannot read.
		1375	async fn forget(db: &D1Database, username: &str, repo_ids: &[String]) -> Result<()> {
		1376	let marks = vec!["?"; repo_ids.len()].join(", ");
		1377	let mut values: Vec<JsValue> = vec![username.into()];
		1378	values.extend(repo_ids.iter().map(|id| JsValue::from(id.as_str())));
Inbox: threads, reasons, subscriptions and watching1d ago		1379	db.batch(vec![
		1380	db.prepare(format!(
		1381	"DELETE FROM inbox_activity WHERE item_id IN (SELECT id FROM inbox_items WHERE username = ? AND repo_id IN ({marks}))"
		1382	))
		1383	.bind(&values)?,
		1384	db.prepare(format!("DELETE FROM inbox_items WHERE username = ? AND repo_id IN ({marks})"))
		1385	.bind(&values)?,
		1386	])
		1387	.await?;
Inbox: the events service tells people what needs them as events arrive1d ago		1388	Ok(())
		1389	}
		1390
		1391	#[derive(Deserialize)]
		1392	struct CountRow {
		1393	severity: String,
		1394	n: f64,
		1395	}
		1396
		1397	pub async fn counts(db: &D1Database, a: InboxCountsArgs) -> Result<InboxCounts> {
		1398	let rows = db
		1399	.prepare(
		1400	"SELECT severity, count(*) AS n FROM inbox_items
		1401	WHERE username = ? AND read_at IS NULL AND done_at IS NULL
		1402	AND (snoozed_until IS NULL OR snoozed_until <= ?)
		1403	GROUP BY severity",
		1404	)
		1405	.bind(&[a.username.to_lowercase().into(), rfc3339(now_ms()).into()])?
		1406	.all()
		1407	.await?
		1408	.results::<CountRow>()?;
		1409	let mut counts = InboxCounts::default();
		1410	for row in rows {
		1411	let n = row.n as u32;
		1412	counts.unread += n;
		1413	match Severity::parse(&row.severity) {
		1414	Some(Severity::Error) => counts.error += n,
		1415	Some(Severity::Warning) => counts.warning += n,
		1416	Some(Severity::Success) => counts.success += n,
		1417	Some(Severity::Info) | None => counts.info += n,
		1418	}
		1419	}
		1420	Ok(counts)
		1421	}
		1422
		1423	/// The change a mark makes, as a `SET` clause; `?1` is now.
		1424	fn mark_change(mark: InboxMark) -> &'static str {
		1425	match mark {
		1426	InboxMark::Read => "read_at = COALESCE(read_at, ?1)",
		1427	InboxMark::Unread => "read_at = NULL",
		1428	InboxMark::Done => "done_at = ?1, read_at = COALESCE(read_at, ?1)",
		1429	InboxMark::Undone => "done_at = NULL",
		1430	InboxMark::Save => "saved = 1",
		1431	InboxMark::Unsave => "saved = 0",
		1432	InboxMark::Snooze => "snoozed_until = ?2, read_at = COALESCE(read_at, ?1)",
Inbox: threads, reasons, subscriptions and watching1d ago		1433	InboxMark::Unsnooze => "snoozed_until = NULL",
Inbox: the events service tells people what needs them as events arrive1d ago		1434	}
		1435	}
		1436
		1437	#[derive(Deserialize)]
		1438	struct IdRow {
		1439	#[allow(dead_code)]
		1440	id: String,
		1441	}
		1442
		1443	/// Changes the person's own items. Returns how many changed.
		1444	pub async fn mark(db: &D1Database, a: MarkInboxArgs) -> Result<u32> {
		1445	let now = rfc3339(now_ms());
		1446	let until = match (a.mark, a.until.as_deref().map(str::trim)) {
		1447	// Times compare as text (`g1t_contracts::time`); a snooze is for later.
		1448	(InboxMark::Snooze, Some(until)) if until.len() == now.len() && until > now.as_str() => until.to_owned(),
		1449	(InboxMark::Snooze, _) => return Ok(0),
		1450	_ => String::new(),
		1451	};
		1452	let mut values: Vec<JsValue> = vec![now.as_str().into(), until.as_str().into(), a.username.to_lowercase().into()];
		1453	let target = if a.all && a.ids.is_empty() {
		1454	let mut target = "done_at IS NULL".to_owned();
Inbox: threads, reasons, subscriptions and watching1d ago		1455	let mut bind = |values: &mut Vec<JsValue>, value: &str, condition: &str| {
		1456	values.push(value.into());
		1457	target.push_str(&format!(" AND {}", condition.replace('?', &format!("?{}", values.len()))));
		1458	};
Inbox: the events service tells people what needs them as events arrive1d ago		1459	if let Some(severity) = a.severity {
Inbox: threads, reasons, subscriptions and watching1d ago		1460	bind(&mut values, severity.as_str(), "severity = ?");
		1461	}
		1462	if let Some(repo_id) = &a.repo_id {
		1463	bind(&mut values, repo_id, "repo_id = ?");
		1464	}
		1465	if let Some(last_read_at) = a.last_read_at.as_deref().map(str::trim).filter(|at| !at.is_empty()) {
		1466	bind(&mut values, last_read_at, "COALESCE(updated_at, created_at) <= ?");
Inbox: the events service tells people what needs them as events arrive1d ago		1467	}
		1468	target
		1469	} else {
		1470	let ids: Vec<&String> = a.ids.iter().take(MAX_MARK).collect();
		1471	if ids.is_empty() {
		1472	return Ok(0);
		1473	}
		1474	let first = values.len() + 1;
		1475	values.extend(ids.iter().map(|id| JsValue::from(id.as_str())));
		1476	let marks: Vec<String> = (first..values.len() + 1).map(|at| format!("?{at}")).collect();
		1477	format!("id IN ({})", marks.join(", "))
		1478	};
		1479	let changed = db
		1480	.prepare(format!(
		1481	"UPDATE inbox_items SET {} WHERE username = ?3 AND {target} RETURNING id",
		1482	mark_change(a.mark)
		1483	))
		1484	.bind(&values)?
		1485	.all()
		1486	.await?
		1487	.results::<IdRow>()?;
		1488	Ok(changed.len() as u32)
		1489	}
		1490
Inbox: threads, reasons, subscriptions and watching1d ago		1491	#[derive(Deserialize)]
		1492	struct ActivityRow {
		1493	reason: String,
		1494	severity: String,
		1495	title: String,
		1496	body: String,
		1497	event: Option<String>,
		1498	actor: Option<String>,
		1499	created_at: String,
		1500	}
		1501
		1502	/// One of the viewer's threads, with its history and their subscription.
		1503	pub async fn thread(db: &D1Database, repos: &Fetcher, work: &Fetcher, a: ThreadArgs) -> Result<Option<InboxThread>> {
		1504	let Some(viewer) = &a.viewer else {
		1505	return Ok(None);
		1506	};
		1507	let username = viewer.username.to_lowercase();
		1508	let row = db
		1509	.prepare(format!("SELECT {COLUMNS} FROM inbox_items WHERE id = ? AND username = ?"))
		1510	.bind(&[a.id.as_str().into(), username.as_str().into()])?
		1511	.first::<Row>(None)
		1512	.await?;
		1513	let Some(row) = readable_only(db, repos, &a.viewer, &username, row.into_iter().collect()).await?.pop() else {
		1514	return Ok(None);
		1515	};
		1516	let activity = db
		1517	.prepare(
		1518	"SELECT reason, severity, title, body, event, actor, created_at FROM inbox_activity
		1519	WHERE item_id = ? ORDER BY id DESC LIMIT ?",
		1520	)
		1521	.bind(&[row.id.as_str().into(), MAX_ACTIVITY.into()])?
		1522	.all()
		1523	.await?
		1524	.results::<ActivityRow>()?
		1525	.into_iter()
		1526	.map(|row| InboxActivity {
		1527	reason: Reason::parse(&row.reason).unwrap_or(Reason::Subscribed),
		1528	severity: Severity::parse(&row.severity).unwrap_or(Severity::Info),
		1529	title: row.title,
		1530	body: row.body,
		1531	event: row.event,
		1532	actor: row.actor,
		1533	created_at: row.created_at,
		1534	})
		1535	.collect();
		1536	let item = row.into_item();
		1537	let subscription = match (item.subject, item.number) {
		1538	(Some(SubjectKind::Issue | SubjectKind::Pull), Some(_)) => {
		1539	subscriptions::subscription(
		1540	db,
		1541	work,
		1542	SubscriptionArgs {
		1543	viewer: a.viewer.clone(),
		1544	id: Some(item.id.clone()),
		1545	..SubscriptionArgs::default()
		1546	},
		1547	)
		1548	.await?
		1549	}
		1550	_ => None,
		1551	};
		1552	Ok(Some(InboxThread {
		1553	item,
		1554	activity,
		1555	subscription,
		1556	}))
		1557	}
		1558
Inbox: the events service tells people what needs them as events arrive1d ago		1559	// --- Keeping up ------------------------------------------------------------------
		1560
		1561	/// Moves rows with renamed workspaces and repositories, and drops those
		1562	/// of purged repositories and deleted workspaces.
		1563	pub async fn follow(db: &D1Database, events: &[Event]) -> Result<()> {
		1564	let mut statements = Vec::new();
		1565	for event in events {
		1566	let text = |key: &str| event.data[key].as_str().unwrap_or_default().to_lowercase();
		1567	match event.kind.as_str() {
		1568	"workspace.renamed" => {
		1569	let Ok(renamed) = serde_json::from_value::<WorkspaceRenamed>(event.data.clone()) else {
		1570	continue;
		1571	};
		1572	let (from, to) = (renamed.from.to_lowercase(), renamed.to.to_lowercase());
		1573	if from == to {
		1574	continue;
		1575	}
		1576	statements.push(
		1577	db.prepare(
Inbox: threads, reasons, subscriptions and watching1d ago		1578	"UPDATE inbox_items SET repo = ?2 || substr(repo, length(?1) + 1), workspace = ?2,
		1579	link = CASE WHEN link LIKE '/' || ?1 || '/%' THEN '/' || ?2 || substr(link, length(?1) + 2) ELSE link END
Inbox: the events service tells people what needs them as events arrive1d ago		1580	WHERE workspace = ?1",
		1581	)
		1582	.bind(&[from.as_str().into(), to.as_str().into()])?,
		1583	);
Inbox: threads, reasons, subscriptions and watching1d ago		1584	statements.push(
		1585	db.prepare("UPDATE inbox_watching SET repo = ?2 || substr(repo, length(?1) + 1) WHERE repo LIKE ?1 || '/%'")
		1586	.bind(&[from.as_str().into(), to.as_str().into()])?,
		1587	);
Inbox: the events service tells people what needs them as events arrive1d ago		1588	}
Inbox: threads, reasons, subscriptions and watching1d ago		1589	"repo.renamed" => {
		1590	let path = format!("{}/{}", text("namespace"), text("to"));
		1591	for table in ["inbox_items", "inbox_watching"] {
		1592	statements.push(
		1593	db.prepare(format!("UPDATE {table} SET repo = ? WHERE repo_id = ?"))
		1594	.bind(&[path.as_str().into(), text("repoId").into()])?,
		1595	);
		1596	}
		1597	}
		1598	"repo.transferred" => {
		1599	let path = format!("{}/{}", text("to"), text("name"));
		1600	statements.push(
		1601	db.prepare("UPDATE inbox_items SET repo = ?, workspace = ? WHERE repo_id = ?")
		1602	.bind(&[path.as_str().into(), text("to").into(), text("repoId").into()])?,
		1603	);
		1604	statements.push(
		1605	db.prepare("UPDATE inbox_watching SET repo = ? WHERE repo_id = ?")
		1606	.bind(&[path.as_str().into(), text("repoId").into()])?,
		1607	);
		1608	}
		1609	"repo.purged" => {
		1610	for sql in [
		1611	"DELETE FROM inbox_activity WHERE item_id IN (SELECT id FROM inbox_items WHERE repo_id = ?)",
		1612	"DELETE FROM inbox_items WHERE repo_id = ?",
		1613	"DELETE FROM inbox_subscriptions WHERE repo_id = ?",
		1614	"DELETE FROM inbox_watching WHERE repo_id = ?",
		1615	] {
		1616	statements.push(db.prepare(sql).bind(&[text("repoId").into()])?);
		1617	}
		1618	}
		1619	"workspace.deleted" => {
		1620	statements.push(
		1621	db.prepare("DELETE FROM inbox_items WHERE workspace = ?")
		1622	.bind(&[text("slug").into()])?,
		1623	);
		1624	statements.push(
		1625	db.prepare("DELETE FROM inbox_watching WHERE repo LIKE ? || '/%'")
		1626	.bind(&[text("slug").into()])?,
		1627	);
		1628	}
Inbox: the events service tells people what needs them as events arrive1d ago		1629	_ => {}
		1630	}
		1631	}
		1632	if !statements.is_empty() {
		1633	db.batch(statements).await?;
		1634	}
		1635	Ok(())
		1636	}
		1637
		1638	/// Removes items done more than [`DONE_DAYS`] ago, and any not saved older
Inbox: threads, reasons, subscriptions and watching1d ago		1639	/// than [`MAX_DAYS`], with their history. Returns how many went.
Inbox: the events service tells people what needs them as events arrive1d ago		1640	pub async fn purge(db: &D1Database, now: u64) -> Result<u32> {
		1641	let done = crate::audit::keep_from(now, DONE_DAYS);
		1642	let oldest = crate::audit::keep_from(now, MAX_DAYS);
Inbox: threads, reasons, subscriptions and watching1d ago		1643	let statements: Vec<D1PreparedStatement> = vec![
		1644	db.prepare("DELETE FROM inbox_items WHERE saved = 0 AND done_at < ?")
		1645	.bind(&[done.into()])?,
		1646	db.prepare("DELETE FROM inbox_items WHERE saved = 0 AND COALESCE(updated_at, created_at) < ?")
		1647	.bind(&[oldest.into()])?,
		1648	db.prepare("DELETE FROM inbox_activity WHERE NOT EXISTS (SELECT 1 FROM inbox_items WHERE inbox_items.id = inbox_activity.item_id)"),
		1649	];
		1650	let results = db.batch(statements).await?;
Inbox: the events service tells people what needs them as events arrive1d ago		1651	let mut removed = 0;
Inbox: threads, reasons, subscriptions and watching1d ago		1652	for result in results.into_iter().take(2) {
Inbox: the events service tells people what needs them as events arrive1d ago		1653	removed += result.meta()?.and_then(|meta| meta.changes).unwrap_or(0) as u32;
		1654	}
		1655	Ok(removed)
		1656	}
		1657
		1658	#[cfg(test)]
		1659	mod tests {
		1660	use super::*;
Inbox: threads, reasons, subscriptions and watching1d ago		1661	use crate::subscriptions::{State, Subscription, Watcher};
Inbox: the events service tells people what needs them as events arrive1d ago		1662	use serde_json::json;
		1663
		1664	fn event(kind: &str, actor: Option<&str>, data: serde_json::Value) -> Event {
		1665	Event {
		1666	id: "evt_1".into(),
		1667	kind: kind.into(),
		1668	source: "work".into(),
		1669	time: "2026-10-07T12:00:00.000Z".into(),
		1670	repo_id: Some("rep_1".into()),
		1671	actor: actor.map(str::to_owned),
		1672	data,
		1673	}
		1674	}
		1675
		1676	fn person(id: &str, username: &str) -> Principal {
		1677	Principal {
		1678	id: id.into(),
		1679	username: username.into(),
		1680	}
		1681	}
		1682
		1683	fn actor(id: &str, username: &str) -> Actor {
		1684	Actor {
		1685	id: Some(id.into()),
		1686	username: Some(username.into()),
		1687	}
		1688	}
		1689
		1690	/// A pull request ana opened, assigned to bo, for an issue cy filed and dee is assigned.
		1691	fn pull() -> InboxSubject {
		1692	InboxSubject {
		1693	kind: Some(SubjectKind::Pull),
		1694	title: "Add the inbox".into(),
		1695	author: person("usr_ana", "ana"),
		1696	assignees: vec!["bo".into()],
		1697	issue: Some(Box::new(InboxSubject {
		1698	kind: Some(SubjectKind::Issue),
		1699	title: "An inbox".into(),
		1700	author: person("usr_cy", "cy"),
		1701	assignees: vec!["dee".into()],
		1702	..InboxSubject::default()
		1703	})),
		1704	..InboxSubject::default()
		1705	}
		1706	}
		1707
		1708	/// A change g1t made for ana.
		1709	fn g1t_pull() -> InboxSubject {
		1710	InboxSubject {
		1711	author: person(AGENT_ID, "g1t"),
		1712	requested_by: Some(person("usr_ana", "ana")),
		1713	..pull()
		1714	}
		1715	}
		1716
Inbox: threads, reasons, subscriptions and watching1d ago		1717	fn nobody() -> Audience {
		1718	Audience::default()
		1719	}
		1720
		1721	fn told(notices: &[Notice]) -> Vec<(&str, Reason, Severity)> {
Inbox: the events service tells people what needs them as events arrive1d ago		1722	notices
		1723	.iter()
		1724	.map(|notice| (notice.username.as_str(), notice.reason, notice.severity))
		1725	.collect()
		1726	}
		1727
		1728	fn comment(author: Principal, body: &str, mentions: &[&str]) -> InboxSubject {
		1729	InboxSubject {
		1730	comment: Some(InboxComment {
		1731	author,
		1732	excerpt: body.into(),
		1733	mentions: mentions.iter().map(|name| (*name).to_owned()).collect(),
		1734	..InboxComment::default()
		1735	}),
		1736	..pull()
		1737	}
		1738	}
		1739
Inbox: threads, reasons, subscriptions and watching1d ago		1740	fn subscribed(rows: &[(&str, State, Option<Reason>)]) -> Audience {
		1741	Audience {
		1742	subscriptions: rows
		1743	.iter()
		1744	.map(|(name, state, reason)| Subscription {
		1745	username: (*name).into(),
		1746	state: *state,
		1747	reason: *reason,
		1748	})
		1749	.collect(),
		1750	watchers: Vec::new(),
		1751	}
		1752	}
		1753
		1754	fn watched(rows: &[(&str, WatchLevel, &[&str])]) -> Audience {
		1755	Audience {
		1756	subscriptions: Vec::new(),
		1757	watchers: rows
		1758	.iter()
		1759	.map(|(name, level, events)| Watcher {
		1760	username: (*name).into(),
		1761	level: *level,
		1762	events: events.iter().map(|kind| (*kind).to_owned()).collect(),
		1763	})
		1764	.collect(),
		1765	}
		1766	}
		1767
Inbox: the events service tells people what needs them as events arrive1d ago		1768	#[test]
		1769	fn only_events_that_tell_someone_are_read() {
		1770	let asked = |kind: &str, data| wants(&event(kind, None, data));
		1771	assert_eq!(
		1772	asked("checks.completed", json!({ "repoId": "rep_1", "number": 4, "status": "failed" })),
		1773	Some(Wanted { repo_id: "rep_1".into(), number: Some(4), comment_id: None })
		1774	);
		1775	assert_eq!(asked("checks.completed", json!({ "repoId": "rep_1", "number": 4, "status": "passed" })), None);
		1776	assert_eq!(asked("review.completed", json!({ "repoId": "rep_1", "number": 4 })), None);
		1777	assert_eq!(asked("workflow.completed", json!({ "repoId": "rep_1", "conclusion": "success" })), None);
		1778	assert_eq!(
		1779	asked("workflow.completed", json!({ "repoId": "rep_1", "conclusion": "failure" })),
		1780	Some(Wanted { repo_id: "rep_1".into(), number: None, comment_id: None })
		1781	);
		1782	assert_eq!(
		1783	asked("comment.created", json!({ "repoId": "rep_1", "number": 2, "commentId": "cmt_1" })).map(|w| w.comment_id),
		1784	Some(Some("cmt_1".into()))
		1785	);
		1786	assert_eq!(asked("git.push", json!({ "repoId": "rep_1" })), None);
Inbox: threads, reasons, subscriptions and watching1d ago		1787	for kind in ["issue.opened", "pull.review_requested", "pull.stalled", "issue.assigned", "pull.closed", "issue.reopened"] {
		1788	assert!(asked(kind, json!({ "repoId": "rep_1", "number": 1 })).is_some(), "{kind}");
		1789	}
		1790	assert_eq!(asked("deployment.failed", json!({ "repoId": "rep_1" })).map(|w| w.number), Some(None));
Inbox: the events service tells people what needs them as events arrive1d ago		1791	}
		1792
		1793	#[test]
Inbox: threads, reasons, subscriptions and watching1d ago		1794	fn a_waiting_or_stopped_agent_needs_the_pull_requests_and_the_issues_people_first() {
Inbox: the events service tells people what needs them as events arrive1d ago		1795	let asked = event("agent.asked", Some("usr_agent"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching1d ago		1796	let notices_ = notices(&asked, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
Inbox: the events service tells people what needs them as events arrive1d ago		1797	assert_eq!(
Inbox: threads, reasons, subscriptions and watching1d ago		1798	told(&notices_),
Inbox: the events service tells people what needs them as events arrive1d ago		1799	vec![
Inbox: threads, reasons, subscriptions and watching1d ago		1800	("ana", Reason::Agent, Severity::Warning),
		1801	("cy", Reason::Agent, Severity::Warning),
		1802	("dee", Reason::Agent, Severity::Warning),
Inbox: the events service tells people what needs them as events arrive1d ago		1803	]
		1804	);
Inbox: threads, reasons, subscriptions and watching1d ago		1805	assert_eq!(notices_[0].title, "An agent is waiting on acme/rocket#7");
		1806	assert_eq!(notices_[0].body, "Add the inbox");
		1807	// Stopping says why; even someone who unsubscribed hears of it.
		1808	let stalled = event("pull.stalled", None, json!({ "number": 7, "detail": "Its checks could not be run." }));
		1809	let audience = subscribed(&[("ana", State::Unsubscribed, None)]);
		1810	let notices_ = notices(&stalled, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &audience);
		1811	assert_eq!(notices_[0].username, "ana");
		1812	assert_eq!(notices_[0].title, "g1t stopped on acme/rocket#7 and needs you");
		1813	assert_eq!(notices_[0].body, "Its checks could not be run.");
		1814	// Ignoring the thread silences even that.
		1815	let audience = subscribed(&[("ana", State::Ignored, None)]);
		1816	let notices_ = notices(&stalled, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &audience);
		1817	assert!(!notices_.iter().any(|notice| notice.username == "ana"));
		1818	}
		1819
		1820	#[test]
		1821	fn whatever_an_agent_waits_on_closes_when_it_goes_on() {
		1822	for kind in RESUMES {
		1823	assert_eq!(resolves(&event(kind, None, json!({ "repoId": "rep_1", "number": 7 }))), Some("rep_1#7".into()));
		1824	}
		1825	assert_eq!(resolves(&event("comment.created", None, json!({ "repoId": "rep_1", "number": 7 }))), None);
Inbox: the events service tells people what needs them as events arrive1d ago		1826	}
		1827
		1828	#[test]
Merge branch 'worktree-agent-a3abfcce648e87dca'1d ago		1829	fn a_deployments_reviewers_are_told() {
		1830	let asked = event(
		1831	"deployment.review_requested",
		1832	Some("usr_ana"),
		1833	json!({
		1834	"repoId": "rep_1", "runId": "run_7", "environment": "production", "workflow": "Deploy",
		1835	"title": "Ship it", "notify": ["cy", "ana"], "link": "/acme/rocket/actions/runs/run_7"
		1836	}),
		1837	);
		1838	let wanted = wants(&asked).unwrap();
		1839	assert_eq!(wanted.number, None);
		1840	let thread = thread_of(&asked, &wanted, None);
		1841	assert_eq!(thread.key, "rep_1/review/run_7/production");
		1842	assert_eq!(thread.link.as_deref(), Some("/acme/rocket/actions/runs/run_7"));
		1843	let told = notices(&asked, "acme/rocket", &actor("usr_ana", "ana"), None, &nobody());
		1844	let names: Vec<&str> = told.iter().map(|notice| notice.username.as_str()).collect();
		1845	// Whoever started the run is told too, when they review it.
		1846	assert_eq!(names, ["cy", "ana"]);
		1847	assert!(told[0].title.contains("waiting for your review to deploy to production"));
		1848	}
		1849
		1850	#[test]
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		1851	fn teams_asked_to_review_tell_the_people_they_name() {
		1852	let requested = event(
		1853	"pull.review_requested",
		1854	Some("usr_ana"),
		1855	json!({ "number": 7, "reviewers": ["cy"], "teams": [
		1856	{ "team": "acme/backend", "notified": ["cy", "dee", "ana"], "assigned": ["cy"] }
		1857	] }),
		1858	);
		1859	let notices_ = notices(&requested, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1860	// cy was picked and is told as a reviewer; dee through the team;
		1861	// never whoever asked.
		1862	assert_eq!(
		1863	told(&notices_),
		1864	vec![("cy", Reason::ReviewRequested, Severity::Warning), ("dee", Reason::ReviewRequested, Severity::Warning)]
		1865	);
		1866	assert_eq!(notices_[0].title, "ana asked you to review acme/rocket#7");
		1867	assert_eq!(notices_[1].title, "ana asked @acme/backend to review acme/rocket#7");
		1868	assert_eq!(
		1869	subscribes(&requested, Some(&pull())),
		1870	vec![("cy".into(), Reason::ReviewRequested), ("dee".into(), Reason::ReviewRequested), ("ana".into(), Reason::ReviewRequested)]
		1871	);
		1872	// Asked by the CODEOWNERS file.
		1873	let owned = event(
		1874	"pull.review_requested",
		1875	None,
		1876	json!({ "number": 7, "reviewers": ["bo"], "codeOwners": true, "teams": [{ "team": "acme/docs", "notified": ["wren"], "assigned": [] }] }),
		1877	);
		1878	let notices_ = notices(&owned, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
		1879	assert_eq!(notices_[0].title, "acme/rocket#7 changes files you own");
		1880	assert_eq!(notices_[1].title, "acme/rocket#7 changes files @acme/docs owns");
		1881	}
		1882
		1883	#[test]
		1884	fn a_team_mention_tells_its_people_once_and_a_name_wins() {
		1885	let mut on = comment(person("usr_bo", "bo"), "cc @ana @acme/backend", &["ana"]);
		1886	if let Some(comment) = on.comment.as_mut() {
		1887	comment.team_mentions = vec![TeamMentioned {
		1888	team: "acme/backend".into(),
		1889	members: vec!["ana".into(), "cy".into(), "bo".into()],
		1890	}];
		1891	}
		1892	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		1893	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody());
		1894	let mentioned: Vec<(&str, Reason)> = notices_.iter().map(|n| (n.username.as_str(), n.reason)).filter(|(_, r)| matches!(r, Reason::Mention | Reason::TeamMention)).collect();
		1895	assert_eq!(mentioned, vec![("ana", Reason::Mention), ("cy", Reason::TeamMention)]);
		1896	assert_eq!(
		1897	notices_.iter().find(|n| n.username == "cy").unwrap().title,
		1898	"bo mentioned @acme/backend on acme/rocket#7"
		1899	);
		1900	let subscribed = subscribes(&created, Some(&on));
		1901	assert!(subscribed.contains(&("cy".into(), Reason::TeamMention)));
		1902	assert!(subscribed.contains(&("ana".into(), Reason::Mention)));
		1903	}
		1904
		1905	#[test]
		1906	fn a_description_tells_the_people_and_teams_it_mentions() {
		1907	let mut on = pull();
		1908	on.mentions = vec!["dee".into()];
		1909	on.team_mentions = vec![TeamMentioned {
		1910	team: "acme/web".into(),
		1911	members: vec!["eve".into()],
		1912	}];
		1913	let opened = event("pull.opened", Some("usr_ana"), json!({ "number": 7 }));
		1914	let notices_ = notices(&opened, "acme/rocket", &actor("usr_ana", "ana"), Some(&on), &nobody());
		1915	assert!(told(&notices_).contains(&("dee", Reason::Mention, Severity::Info)));
		1916	assert!(told(&notices_).contains(&("eve", Reason::TeamMention, Severity::Info)));
		1917	assert_eq!(
		1918	subscribes(&opened, Some(&on)),
		1919	vec![("dee".into(), Reason::Mention), ("eve".into(), Reason::TeamMention)]
		1920	);
		1921	}
		1922
		1923	#[test]
Inbox: threads, reasons, subscriptions and watching1d ago		1924	fn reviewers_and_assignees_asked_are_told_never_whoever_asked() {
		1925	let requested = event("pull.review_requested", Some("usr_ana"), json!({ "number": 7, "reviewers": ["bo", "g1t", "ana"] }));
		1926	let notices_ = notices(&requested, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1927	assert_eq!(told(&notices_), vec![("bo", Reason::ReviewRequested, Severity::Warning)]);
		1928	assert_eq!(notices_[0].title, "ana asked you to review acme/rocket#7");
		1929	let assigned = event("issue.assigned", Some("usr_ana"), json!({ "number": 3, "added": ["ana", "eve"] }));
		1930	let notices_ = notices(&assigned, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1931	assert_eq!(told(&notices_), vec![("eve", Reason::Assign, Severity::Info)]);
		1932	assert_eq!(notices_[0].title, "ana assigned you to acme/rocket#3");
		1933	// Both subscribe whoever they name, never g1t.
		1934	assert_eq!(subscribes(&requested, Some(&pull())), vec![("bo".into(), Reason::ReviewRequested), ("ana".into(), Reason::ReviewRequested)]);
		1935	assert_eq!(subscribes(&assigned, Some(&pull())), vec![("ana".into(), Reason::Assign), ("eve".into(), Reason::Assign)]);
		1936	}
		1937
		1938	#[test]
Inbox: the events service tells people what needs them as events arrive1d ago		1939	fn failures_go_to_whoever_answers_for_the_change() {
		1940	let failed = event("checks.completed", None, json!({ "number": 7, "status": "failed" }));
Inbox: threads, reasons, subscriptions and watching1d ago		1941	assert_eq!(
		1942	told(&notices(&failed, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		1943	vec![("ana", Reason::CiActivity, Severity::Error)]
		1944	);
Inbox: the events service tells people what needs them as events arrive1d ago		1945	// g1t's change is the person's who asked for it, never g1t's.
Inbox: threads, reasons, subscriptions and watching1d ago		1946	let notices_ = notices(&failed, "acme/rocket", &Actor::default(), Some(&g1t_pull()), &nobody());
		1947	assert_eq!(told(&notices_), vec![("ana", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive1d ago		1948	let errored = event("checks.completed", None, json!({ "number": 7, "status": "errored" }));
Inbox: threads, reasons, subscriptions and watching1d ago		1949	assert_eq!(
		1950	notices(&errored, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())[0].title,
		1951	"Checks could not run on acme/rocket#7"
		1952	);
Inbox: the events service tells people what needs them as events arrive1d ago		1953	}
		1954
		1955	#[test]
		1956	fn a_workflow_that_fails_tells_its_pull_requests_owner_even_if_they_pushed() {
		1957	let failed = event("workflow.completed", Some("usr_ana"), json!({ "pull": 7, "workflow": "CI", "conclusion": "failure" }));
Inbox: threads, reasons, subscriptions and watching1d ago		1958	let notices_ = notices(&failed, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		1959	assert_eq!(told(&notices_), vec![("ana", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive1d ago		1960	assert_eq!(notices_[0].title, "CI failed on acme/rocket#7");
		1961	// On a branch: whoever pushed.
		1962	let pushed = event(
		1963	"workflow.completed",
		1964	Some("usr_bo"),
Inbox: threads, reasons, subscriptions and watching1d ago		1965	json!({ "workflow": "Deploy", "path": ".g1t/workflows/deploy.yml", "conclusion": "failure", "ref": "refs/heads/main", "number": 12, "sha": "abcdef0123", "runId": "run_9" }),
Inbox: the events service tells people what needs them as events arrive1d ago		1966	);
Inbox: threads, reasons, subscriptions and watching1d ago		1967	let notices_ = notices(&pushed, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody());
		1968	assert_eq!(told(&notices_), vec![("bo", Reason::CiActivity, Severity::Error)]);
Inbox: the events service tells people what needs them as events arrive1d ago		1969	assert_eq!(notices_[0].title, "Deploy failed on main in acme/rocket");
		1970	assert_eq!(notices_[0].body, "Run 12 at abcdef0");
		1971	// Nobody to tell when g1t pushed.
Inbox: threads, reasons, subscriptions and watching1d ago		1972	assert!(notices(&pushed, "acme/rocket", &actor("g1t", "g1t"), None, &nobody()).is_empty());
		1973	// Every failure of a workflow on a branch is one thread.
		1974	let wanted = wants(&pushed).unwrap();
		1975	let thread = thread_of(&pushed, &wanted, None);
		1976	assert_eq!(thread.key, "rep_1/run/.g1t/workflows/deploy.yml@main");
		1977	assert_eq!(thread.run_id.as_deref(), Some("run_9"));
		1978	}
		1979
		1980	#[test]
		1981	fn deployments_tell_whoever_answers_for_them_and_watchers() {
		1982	let failed = event(
		1983	"deployment.failed",
		1984	Some("usr_bo"),
		1985	json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "deploymentId": "dpl_1", "error": "The build failed.", "path": "/acme/rocket/deployments/dpl_1" }),
		1986	);
		1987	let audience = watched(&[("cy", WatchLevel::Custom, &["deployments"]), ("dee", WatchLevel::Custom, &["issues"]), ("eve", WatchLevel::All, &[])]);
		1988	let notices_ = notices(&failed, "acme/rocket", &actor("usr_bo", "bo"), None, &audience);
		1989	assert_eq!(
		1990	told(&notices_),
		1991	vec![
		1992	("bo", Reason::CiActivity, Severity::Error),
		1993	("cy", Reason::Subscribed, Severity::Error),
		1994	("eve", Reason::Subscribed, Severity::Error),
		1995	]
		1996	);
		1997	assert_eq!(notices_[0].title, "Production of rocket failed to deploy");
		1998	assert_eq!(notices_[0].body, "The build failed.");
		1999	let thread = thread_of(&failed, &wants(&failed).unwrap(), None);
		2000	assert_eq!(thread.key, "rep_1/deploy/prj_1/production");
		2001	assert_eq!(url(Some("acme/rocket"), thread.kind, None, None, thread.link.as_deref()), "/acme/rocket/deployments/dpl_1");
		2002	// A success is news to the owner only after a failure.
		2003	let live = event("deployment.succeeded", Some("usr_bo"), json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "commit": "abcdef0123" }));
		2004	assert!(notices(&live, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody()).is_empty());
		2005	let recovered = event("deployment.succeeded", Some("usr_bo"), json!({ "repoId": "rep_1", "projectId": "prj_1", "project": "rocket", "recovered": true }));
		2006	let notices_ = notices(&recovered, "acme/rocket", &actor("usr_bo", "bo"), None, &nobody());
		2007	assert_eq!(told(&notices_), vec![("bo", Reason::CiActivity, Severity::Success)]);
		2008	assert_eq!(notices_[0].title, "Production of rocket is live again");
		2009	// A preview's is the pull request's owner's.
		2010	let preview = event("deployment.failed", None, json!({ "repoId": "rep_1", "projectId": "prj_1", "number": 7, "triggeredBy": "g1t" }));
		2011	assert_eq!(told(&notices(&preview, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())), vec![("ana", Reason::CiActivity, Severity::Error)]);
		2012	assert_eq!(thread_of(&preview, &wants(&preview).unwrap(), Some(&pull())).key, "rep_1/deploy/prj_1/7");
Inbox: the events service tells people what needs them as events arrive1d ago		2013	}
		2014
		2015	#[test]
Teams and CODEOWNERS, labels and milestones, dependency updates, the security suite, and a clearer top bar1d ago		2016	fn security_alerts_tell_the_pusher_the_owners_and_member_watchers() {
		2017	let blocked = event(
		2018	"secret_scanning_alert.created",
		2019	None,
		2020	json!({
		2021	"repoId": "rep_1", "alertId": "sec_1", "alertType": "secret_scanning", "severity": "critical",
		2022	"title": "An AWS access key in config/prod.env", "link": "/acme/rocket/security/secret-scanning/sec_1",
		2023	"state": "open", "pusher": "bo", "notify": ["ana"], "members": ["ana", "bo", "cy"]
		2024	}),
		2025	);
		2026	assert_eq!(wants(&blocked), Some(Wanted { repo_id: "rep_1".into(), number: None, comment_id: None }));
		2027	// cy watches for security alerts and is a member; eve watches
		2028	// everything but cannot see findings; dee watches issues only.
		2029	let audience = watched(&[
		2030	("cy", WatchLevel::Custom, &["security"]),
		2031	("dee", WatchLevel::Custom, &["issues"]),
		2032	("eve", WatchLevel::All, &[]),
		2033	]);
		2034	let notices_ = notices(&blocked, "acme/rocket", &Actor::default(), None, &audience);
		2035	assert_eq!(
		2036	told(&notices_),
		2037	vec![
		2038	("bo", Reason::SecurityAlert, Severity::Error),
		2039	("ana", Reason::SecurityAlert, Severity::Error),
		2040	("cy", Reason::SecurityAlert, Severity::Error),
		2041	]
		2042	);
		2043	assert_eq!(notices_[0].title, "A push to acme/rocket was blocked: it adds a secret");
		2044	assert_eq!(notices_[0].body, "An AWS access key in config/prod.env");
		2045	let thread = thread_of(&blocked, &wants(&blocked).unwrap(), None);
		2046	assert_eq!(thread.key, "rep_1/security/sec_1");
		2047	assert_eq!(url(Some("acme/rocket"), thread.kind, None, None, thread.link.as_deref()), "/acme/rocket/security/secret-scanning/sec_1");
		2048	// A bypass request goes to the reviewers named, never to watchers.
		2049	let requested = event(
		2050	"secret_scanning.bypass_requested",
		2051	Some("usr_bo"),
		2052	json!({ "repoId": "rep_1", "alertId": "sec_1", "requestId": "byp_1", "title": "An AWS access key in a.env", "notify": ["ana"], "link": "/acme/-/security/bypass-requests" }),
		2053	);
		2054	let notices_ = notices(&requested, "acme/rocket", &actor("usr_bo", "bo"), None, &audience);
		2055	assert_eq!(told(&notices_), vec![("ana", Reason::SecurityAlert, Severity::Warning)]);
		2056	assert_eq!(notices_[0].title, "bo asked to bypass push protection in acme/rocket");
		2057	// Fixes and dismissals are not news to the inbox.
		2058	assert_eq!(wants(&event("code_scanning_alert.fixed", None, json!({ "repoId": "rep_1" }))), None);
		2059	}
		2060
		2061	#[test]
Inbox: the events service tells people what needs them as events arrive1d ago		2062	fn nobody_hears_of_what_they_did_themselves() {
		2063	let merged = event("pull.merged", Some("usr_ana"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching1d ago		2064	let by_ana = notices(&merged, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody());
		2065	// The assignee still hears; ana, who merged, does not.
		2066	assert_eq!(told(&by_ana), vec![("bo", Reason::StateChange, Severity::Success)]);
		2067	let by_bo = notices(&merged, "acme/rocket", &actor("usr_bo", "bo"), Some(&pull()), &nobody());
		2068	assert_eq!(told(&by_bo), vec![("ana", Reason::StateChange, Severity::Success)]);
Inbox: the events service tells people what needs them as events arrive1d ago		2069	assert_eq!(by_bo[0].title, "bo merged acme/rocket#7");
Inbox: threads, reasons, subscriptions and watching1d ago		2070	let by_queue = notices(&merged, "acme/rocket", &Actor::default(), Some(&pull()), &nobody());
Inbox: the events service tells people what needs them as events arrive1d ago		2071	assert_eq!(by_queue[0].title, "acme/rocket#7 was merged");
		2072	}
		2073
		2074	#[test]
Inbox: threads, reasons, subscriptions and watching1d ago		2075	fn closing_and_reopening_tells_everyone_subscribed_and_watchers() {
		2076	let closed = event("issue.closed", Some("usr_bo"), json!({ "number": 3, "reason": "completed" }));
		2077	let issue = InboxSubject {
		2078	kind: Some(SubjectKind::Issue),
		2079	title: "Crash".into(),
		2080	author: person("usr_cy", "cy"),
		2081	assignees: vec!["bo".into()],
		2082	..InboxSubject::default()
		2083	};
		2084	let mut audience = subscribed(&[("eve", State::Subscribed, Some(Reason::Comment)), ("fay", State::Unsubscribed, None)]);
		2085	audience.watchers = watched(&[("gus", WatchLevel::All, &[]), ("hal", WatchLevel::Custom, &["pulls"])]).watchers;
		2086	let notices_ = notices(&closed, "acme/rocket", &actor("usr_bo", "bo"), Some(&issue), &audience);
		2087	assert_eq!(
		2088	told(&notices_),
		2089	vec![
		2090	("cy", Reason::StateChange, Severity::Info),
		2091	("eve", Reason::StateChange, Severity::Info),
		2092	("gus", Reason::Subscribed, Severity::Info),
		2093	]
		2094	);
		2095	assert_eq!(notices_[0].title, "bo closed acme/rocket#3");
		2096	let by_pull = event("issue.closed", None, json!({ "number": 3, "resolvedBy": 9 }));
		2097	assert_eq!(notices(&by_pull, "acme/rocket", &Actor::default(), Some(&issue), &nobody())[0].title, "acme/rocket#3 was closed by #9");
		2098	let reopened = event("issue.reopened", Some("usr_cy"), json!({ "number": 3 }));
		2099	assert_eq!(told(&notices(&reopened, "acme/rocket", &actor("usr_cy", "cy"), Some(&issue), &nobody())), vec![("bo", Reason::StateChange, Severity::Info)]);
		2100	}
		2101
		2102	#[test]
		2103	fn opening_tells_who_it_names_and_watchers_of_its_kind() {
		2104	let opened = event("pull.opened", Some("usr_ana"), json!({ "number": 7 }));
		2105	let subject = InboxSubject { reviewers: vec!["cy".into(), "g1t".into()], ..pull() };
		2106	let audience = watched(&[("bo", WatchLevel::All, &[]), ("dee", WatchLevel::Custom, &["issues"]), ("eve", WatchLevel::Custom, &["pulls"]), ("fay", WatchLevel::Participating, &[])]);
		2107	let notices_ = notices(&opened, "acme/rocket", &actor("usr_ana", "ana"), Some(&subject), &audience);
		2108	assert_eq!(
		2109	told(&notices_),
		2110	vec![
		2111	("bo", Reason::Assign, Severity::Info),
		2112	("cy", Reason::ReviewRequested, Severity::Warning),
		2113	("eve", Reason::Subscribed, Severity::Info),
		2114	]
		2115	);
		2116	assert_eq!(notices_[2].title, "ana opened acme/rocket#7");
		2117	}
		2118
		2119	#[test]
		2120	fn ignoring_a_repository_silences_it_and_unsubscribing_keeps_only_what_is_asked() {
		2121	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		2122	let on = comment(person("usr_bo", "bo"), "@cy have a look", &["cy"]);
		2123	let audience = watched(&[("cy", WatchLevel::Ignore, &[]), ("ana", WatchLevel::All, &[])]);
		2124	assert!(notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience).iter().all(|notice| notice.username != "cy"));
		2125	let audience = subscribed(&[("cy", State::Unsubscribed, None), ("ana", State::Unsubscribed, None)]);
		2126	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience);
		2127	// cy was mentioned, which is asked of them; ana unsubscribed from the conversation.
		2128	assert_eq!(told(&notices_), vec![("cy", Reason::Mention, Severity::Info)]);
		2129	}
		2130
		2131	#[test]
Inbox: the events service tells people what needs them as events arrive1d ago		2132	fn g1t_finishing_or_reviewing_tells_the_person_it_worked_for() {
		2133	// The agent acts as the person it works for: still an outcome they hear of.
		2134	let ready = event("pull.ready", Some("usr_ana"), json!({ "number": 7 }));
Inbox: threads, reasons, subscriptions and watching1d ago		2135	let notices_ = notices(&ready, "acme/rocket", &actor("usr_ana", "ana"), Some(&g1t_pull()), &nobody());
		2136	assert_eq!(told(&notices_), vec![("ana", Reason::Author, Severity::Success)]);
Inbox: the events service tells people what needs them as events arrive1d ago		2137	assert_eq!(notices_[0].title, "g1t finished acme/rocket#7");
		2138	// A person's draft marked ready is not news to them.
Inbox: threads, reasons, subscriptions and watching1d ago		2139	assert!(notices(&ready, "acme/rocket", &actor("usr_ana", "ana"), Some(&pull()), &nobody()).is_empty());
Inbox: the events service tells people what needs them as events arrive1d ago		2140
		2141	let approve = event("review.completed", None, json!({ "number": 7, "verdict": "approve" }));
Inbox: threads, reasons, subscriptions and watching1d ago		2142	assert_eq!(
		2143	told(&notices(&approve, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		2144	vec![("ana", Reason::Author, Severity::Success)]
		2145	);
Inbox: the events service tells people what needs them as events arrive1d ago		2146	let changes = event("review.completed", None, json!({ "number": 7, "verdict": "request_changes" }));
		2147	assert_eq!(
Inbox: threads, reasons, subscriptions and watching1d ago		2148	told(&notices(&changes, "acme/rocket", &Actor::default(), Some(&pull()), &nobody())),
		2149	vec![("ana", Reason::Author, Severity::Info)]
Inbox: the events service tells people what needs them as events arrive1d ago		2150	);
		2151	}
		2152
		2153	#[test]
Inbox: threads, reasons, subscriptions and watching1d ago		2154	fn comments_tell_those_mentioned_then_everyone_subscribed_never_the_writer() {
Inbox: the events service tells people what needs them as events arrive1d ago		2155	let created = event("comment.created", Some("usr_bo"), json!({ "number": 7, "commentId": "cmt_1" }));
		2156	let on = comment(person("usr_bo", "bo"), "@cy @bo have a look", &["cy", "bo", "g1t"]);
Inbox: threads, reasons, subscriptions and watching1d ago		2157	let audience = subscribed(&[("eve", State::Subscribed, Some(Reason::Comment)), ("fay", State::Subscribed, Some(Reason::Manual))]);
		2158	let notices_ = notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &audience);
Inbox: the events service tells people what needs them as events arrive1d ago		2159	assert_eq!(
		2160	told(&notices_),
Inbox: threads, reasons, subscriptions and watching1d ago		2161	vec![
		2162	("cy", Reason::Mention, Severity::Info),
		2163	("ana", Reason::Author, Severity::Info),
		2164	("eve", Reason::Comment, Severity::Info),
		2165	("fay", Reason::Manual, Severity::Info),
		2166	]
Inbox: the events service tells people what needs them as events arrive1d ago		2167	);
		2168	assert_eq!(notices_[0].title, "bo mentioned you on acme/rocket#7");
Inbox: threads, reasons, subscriptions and watching1d ago		2169	assert_eq!(notices_[1].title, "bo commented on acme/rocket#7");
Inbox: the events service tells people what needs them as events arrive1d ago		2170	assert_eq!(notices_[0].body, "@cy @bo have a look");
		2171	// Mentioned and the owner: told once, as mentioned.
		2172	let on = comment(person("usr_bo", "bo"), "@ana", &["ana"]);
Inbox: threads, reasons, subscriptions and watching1d ago		2173	assert_eq!(
		2174	told(&notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody())),
		2175	vec![("ana", Reason::Mention, Severity::Info)]
		2176	);
		2177	// The owner's own comment tells the assignee, not the owner.
Inbox: the events service tells people what needs them as events arrive1d ago		2178	let on = comment(person("usr_ana", "ana"), "thanks", &[]);
Inbox: threads, reasons, subscriptions and watching1d ago		2179	assert_eq!(
		2180	told(&notices(&created, "acme/rocket", &actor("usr_ana", "ana"), Some(&on), &nobody())),
		2181	vec![("bo", Reason::Assign, Severity::Info)]
		2182	);
Inbox: the events service tells people what needs them as events arrive1d ago		2183	// Something that happened, not something written, tells nobody.
		2184	let mut on = comment(person("usr_bo", "bo"), "assigned cy", &[]);
		2185	on.comment.as_mut().unwrap().event = true;
Inbox: threads, reasons, subscriptions and watching1d ago		2186	assert!(notices(&created, "acme/rocket", &actor("usr_bo", "bo"), Some(&on), &nobody()).is_empty());
Inbox: the events service tells people what needs them as events arrive1d ago		2187	// An approval is good news.
Inbox: threads, reasons, subscriptions and watching1d ago		2188	let mut on = comment(person("usr_cy", "cy"), "", &[]);
Inbox: the events service tells people what needs them as events arrive1d ago		2189	on.comment.as_mut().unwrap().verdict = Some("approve".into());
Inbox: threads, reasons, subscriptions and watching1d ago		2190	let notices_ = notices(&created, "acme/rocket", &actor("usr_cy", "cy"), Some(&on), &nobody());
		2191	assert_eq!(told(&notices_)[0], ("ana", Reason::Author, Severity::Success));
Inbox: the events service tells people what needs them as events arrive1d ago		2192	assert_eq!(notices_[0].body, "Add the inbox");
Inbox: threads, reasons, subscriptions and watching1d ago		2193	// Writing and being mentioned subscribe, never g1t.
		2194	let on = comment(person("usr_bo", "bo"), "@cy", &["cy"]);
		2195	assert_eq!(subscribes(&created, Some(&on)), vec![("bo".into(), Reason::Comment), ("cy".into(), Reason::Mention)]);
		2196	let on = comment(person(AGENT_ID, "g1t"), "done", &[]);
		2197	assert!(subscribes(&created, Some(&on)).is_empty());
		2198	}
		2199
		2200	#[test]
		2201	fn issues_and_pull_requests_are_one_thread_each() {
		2202	let created = event("comment.created", Some("usr_bo"), json!({ "repoId": "rep_1", "number": 7, "commentId": "cmt_1" }));
		2203	let wanted = wants(&created).unwrap();
		2204	let thread = thread_of(&created, &wanted, Some(&pull()));
		2205	assert_eq!(thread.key, "rep_1#7");
		2206	assert_eq!(thread.kind, Some(SubjectKind::Pull));
		2207	let merged = event("pull.merged", None, json!({ "repoId": "rep_1", "number": 7 }));
		2208	assert_eq!(thread_of(&merged, &wants(&merged).unwrap(), Some(&pull())).key, thread.key);
Inbox: the events service tells people what needs them as events arrive1d ago		2209	}
		2210
		2211	#[test]
		2212	fn items_link_to_what_they_are_about() {
Inbox: threads, reasons, subscriptions and watching1d ago		2213	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Pull), Some(7), None, None), "/acme/rocket/pull/7");
		2214	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Issue), Some(3), None, None), "/acme/rocket/issues/3");
		2215	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Run), None, Some("run_1"), None), "/acme/rocket/actions/runs/run_1");
		2216	assert_eq!(url(Some("acme/rocket"), Some(SubjectKind::Deploy), None, None, Some("/acme/site/deployments/dpl_1")), "/acme/site/deployments/dpl_1");
		2217	assert_eq!(url(Some("acme/rocket"), None, None, None, None), "/acme/rocket");
		2218	assert_eq!(url(None, None, None, None, None), "/inbox");
Inbox: the events service tells people what needs them as events arrive1d ago		2219	}
		2220
		2221	#[test]
		2222	fn long_titles_are_cut_to_a_line() {
		2223	let long = "x".repeat(400);
		2224	assert_eq!(clip(&long, MAX_TITLE).chars().count(), MAX_TITLE);
		2225	assert_eq!(clip(" short ", MAX_TITLE), "short");
		2226	}
		2227
		2228	#[test]
		2229	fn marks_change_only_what_they_say() {
		2230	assert_eq!(mark_change(InboxMark::Read), "read_at = COALESCE(read_at, ?1)");
		2231	assert!(mark_change(InboxMark::Done).contains("done_at = ?1"));
Inbox: threads, reasons, subscriptions and watching1d ago		2232	assert_eq!(mark_change(InboxMark::Unsnooze), "snoozed_until = NULL");
		2233	assert!(ranked(&ListInboxArgs::default()));
		2234	assert!(!ranked(&ListInboxArgs { reason: Some(Reason::Mention), ..ListInboxArgs::default() }));
		2235	assert!(!ranked(&ListInboxArgs { participating: true, ..ListInboxArgs::default() }));
		2236	}
		2237
		2238	#[test]
		2239	fn filters_bind_in_order_after_what_is_bound() {
		2240	let a = ListInboxArgs {
		2241	reason: Some(Reason::Mention),
		2242	repo_id: Some("rep_1".into()),
		2243	participating: true,
		2244	unread: true,
		2245	..ListInboxArgs::default()
		2246	};
		2247	// Two values come first: the username and now.
		2248	let (conditions, values) = filters(&a, 2);
		2249	assert_eq!(
		2250	conditions,
		2251	vec!["reason = ?3", "repo_id = ?4", "reason NOT IN ('manual', 'subscribed')", "read_at IS NULL"]
		2252	);
		2253	assert_eq!(values, vec!["mention", "rep_1"]);
		2254	}
		2255
		2256	#[test]
		2257	fn the_bump_keeps_whatever_is_most_urgent_while_unread() {
		2258	assert!(BUMP.contains("WHERE NOT EXISTS (SELECT 1 FROM inbox_activity WHERE event_id = ?4 AND username = ?2)"));
		2259	assert!(BUMP.contains("ON CONFLICT (username, thread) DO UPDATE"));
		2260	assert!(BUMP.contains("activity = inbox_items.activity + 1"));
		2261	// Its numbered parameters run from 1 to 19.
		2262	for at in 1..=19 {
		2263	assert!(BUMP.contains(&format!("?{at}")), "?{at}");
		2264	}
		2265	assert!(!BUMP.contains("?20"));
Inbox: the events service tells people what needs them as events arrive1d ago		2266	}
Fine-grained personal tokens, workspace token rules and approvals in identity1d ago		2267
		2268	#[test]
		2269	fn token_approvals_tell_the_people_named_about_no_repository() {
		2270	let mut asked = event(
		2271	"token.approval_requested",
		2272	Some("usr_ana"),
		2273	json!({ "workspace": "acme", "tokenId": "tok_1", "notify": ["Bo", "cy", "bo", "g1t"], "title": "ana asks", "body": "ci: contents: write", "link": "/acme/-/settings/tokens" }),
		2274	);
		2275	asked.repo_id = None;
		2276	let (thread, told) = workspace_notices(&asked, None);
		2277	assert_eq!(thread, "workspace:acme/token/tok_1");
		2278	let mut names: Vec<&str> = told.iter().map(|notice| notice.username.as_str()).collect();
		2279	names.sort();
		2280	assert_eq!(names, ["bo", "cy"], "each once, lowercased, never g1t");
		2281	assert!(told.iter().all(|notice| notice.reason == Reason::ReviewRequested && notice.severity == Severity::Warning));
		2282	assert!(wants(&asked).is_none(), "about no repository");
		2283	let reviewed = event("token.approval_reviewed", None, json!({ "workspace": "acme", "tokenId": "tok_1", "notify": ["ana"], "title": "approved" }));
		2284	let (_, told) = workspace_notices(&reviewed, None);
		2285	assert_eq!(told[0].reason, Reason::Author);
		2286	assert!(WORKSPACE_EVENTS.contains(&"token.approval_reviewed"));
		2287	}
Inbox: the events service tells people what needs them as events arrive1d ago		2288	}

This file's history is long; its oldest lines are credited to the oldest commit read.